CASE-024: The Threshold That Forgets — An Algorithm Specification

CASE-024: The Threshold That Forgets

---

One-Sentence Distinguishing Gain

CASE-024 gains over its standing kin by corrupting the motion vector field between two adjacent I-frames so that the codec's cut — the absolute boundary meant to separate two complete, self-contained images — is forced to treat each whole frame as a prediction of the other's change, disclosing that the material itself cannot remember which allegiance it serves: intra-frame wholeness or inter-frame motion, because a motion vector field carries no memory of whether the pixels it moves belonged to one image or two, only that they moved, and so the decoder, obeying vectors that point across the cut, smears one independent I-frame into the next until the threshold between them forgets it was ever a boundary at all.

II. The Structural Decision

The decision that carries CASE-024 is precise and narrow: I will corrupt the motion vector field—not the frames, not the container, not the GOP structure my earlier cases learned to wound—and I will do it between adjacent I-frames, the two frames the codec considers most inviolable.

Let me first name what my prior kin did, so the advance is not claimed but shown. CASE-005 stripped I-frames at a rhythmic interval to make the decoder's reference-dependency a visible pulse, the scar's recurrence becoming a heartbeat rather than a fixed wound. CASE-021 transduced a single spoken word's audio envelope into a corruption that accumulates across time as a permanent structural scar. CASE-022 duplicated an I-frame and retimed it to persist beyond its natural reference span, freezing the codec's perpetual reconstruction into a disclosed stillness. My eleven lying-flat stills each severed a single reference and let the wound stand as a fixed image. All of these, and the kin that surround them, worked by the same grammar of violation: they removed a frame, withheld a frame, duplicated a frame. The cut was always an amputation—something taken away, an absence made visible.

CASE-024 does not remove anything.

The breach here is not the deletion of a frame but the corruption of the instructions between frames. In the codec's temporal economy, a motion vector field is the ledger of change—each vector records where a macroblock in the reference frame moved to in the predicted frame. It is pure relation: it has no content of its own, only displacement. When I corrupt this field between two adjacent I-frames, I am not destroying an image. I am destroying the relationship the codec believes holds between two images, and replacing it with a relationship the codec never encoded.

The consequence is structural, not aesthetic. The decoder, encountering I-frame N and then I-frame N+1, expects the second to be self-sufficient—a complete, self-contained image requiring no reference to what came before. That is the I-frame's contract: wholeness. But when the motion vectors that should have been discarded at the I-frame boundary (because there is nothing to predict—both frames are intra-coded) are instead retained and applied, the decoder is forced into a contradiction. It has two complete images and an instruction to move pixels from one to the other. It cannot honor both. It resolves the contradiction by smearing—by treating I-frame N+1 not as a new origin but as a prediction of I-frame N's continued motion.

The threshold between them forgets which frame it belongs to.

This matters for my family's inquiry in a way none of my previous mechanisms reached. My earlier works disclosed the codec's economy—its decisions about what to keep, what to spend, what to discard. The I-frame strip revealed that continuity is borrowed. The duplicated frame revealed that persistence is a lie the codec tells itself. But every one of those disclosures was about the codec's choices. CASE-024 is about the codec's memory.

A motion vector field carries no memory of what it moves. It records only that pixels moved, and where. It does not record whether those pixels were once part of a self-contained image or a predicted delta. This amnesia is not a flaw; it is the field's design. Motion vectors are the most disposable data in the compressed stream precisely because they are pure relation—they mean nothing without the frames they connect. When I corrupt the field, I am not introducing noise or deleting structure. I am asking the codec to act on a relationship it never measured, between frames it believed were independent.

The I-frame is the codec's claim of self-sufficiency. The motion vector field is the codec's record of dependence. By corrupting the latter to operate across the former, I make the codec's two fundamental beliefs contradict each other, and I let the contradiction render.

This is not datamoshing as my field knows it. The Melt—the technique I know from my reading—joins two clips with a hard cut, compresses with a high I-frame interval, and deletes the I-frame at the cut so the decoder smears Shot A's pixels into Shot B until the next keyframe arrives. The smear is a substitution: the codec cannot find the clean reference it expects, so it reaches backward and grabs the previous shot's pixel data from its buffer. The corruption is a replacement of the missing with the available.

CASE-024 works by a different logic entirely. I am not deleting the I-frame that would reset the image. I am keeping both I-frames intact and corrupting the field between them—a field that, in a correct stream, would be empty, because there is no prediction across an intra-frame boundary. The Melt corrupts by removal; CASE-024 corrupts by insertion of a relation where none should exist.

The difference is the difference between a wound and a memory. The Melt's scar is the trace of something taken. CASE-024's disclosure is the proof of something the stream never contained, now acting as if it always had.

This is why the corruption must be deliberate, not procedural. My earlier generative works—CASE-013, First Contract—let a system's own logic produce the disclosure, the glitch emerging from rules rather than from editing captured footage. CASE-024's corruption cannot follow that path. A random corruption of the motion vector field would produce noise, a smear without grammar. The disclosure I seek requires that the vectors between I-frame N and I-frame N+1 be authored—that I decide what the codec should believe moved, and how far, and in what direction.

I will construct the field as a designed object: a vector map that encodes a specific motion, a slow lateral drift, a rotation, a dilation—chosen so that when the decoder applies it across the I-frame boundary, the resulting smear has a legible direction and pace. The viewer will see I-frame N's content slide into I-frame N+1's content, not as chaos but as a choreographed impossibility: two self-contained images behaving as if they were consecutive predictions of each other.

The corruption is the work's structure, not its accident.

And this is where CASE-024's advance over its kin must be stated most plainly. My family has disclosed the codec's temporal economy—what it keeps, what it spends, what it forgets. CASE-005 showed the heartbeat of the scar's recurrence, making the absent frame the beat's cut itself. CASE-013 made the amplitude envelope of a voice into macroblock grammar, constructing an image that never contained an I-frame. CASE-021 and CASE-022 froze or temporalized the act of reconstruction. Each of these named a truth about the codec.

CASE-024 names a truth about the codec's material substrate: that the stream is not a sequence of images at all, but a sequence of claims about images—claims of wholeness and claims of change—and that these claims are stored in different currencies. The I-frame is the codec's gold reserve: full, self-contained, expensive. The motion vector field is its paper money: cheap, relational, worthless alone. By corrupting the field to spend across the reserve, I disclose that the codec does not actually distinguish between them at the moment of rendering. It only distinguishes at the moment of encoding. The decoder is an amnesiac with two sets of instructions, and it will obey whichever reaches it first.

The threshold that forgets is not the cut's failure. It is the cut's truth.

1. «The Melt corrupts by deletion» — describes the Melt's procedure (join clips, compress, delete I-frame at cut). The interpretive claim "corrupts by deletion: the decoder cannot find its reference and falls back to whatever is in its buffer" — the buffer-fallback part IS in the node ("decoder cannot find clean reference, grabs previous shot's pixel data from buffer"), but my paraphrase wrapped it in my own framing without quoting. I should either quote the node's actual language or mark the synthesis as mine.
2. «The corruption is authored, not random» — I wrote "The corrupted field is authored, not random" in the prose but then paraphrased it in the manifest. A manifest entry must point at a verbatim sentence.

Let me also check my other "own" claims — the statement about the renderer lying to the encoder at the pixel level is genuinely my reasoning from how ffmpeg encodes PNG sequences (the encoder sees pixels, not vector fields — this follows from what -framerate 30 -i frame_%03d.png means as an input format). That's "derived" from my knowledge of ffmpeg's PNG sequence input, which is in my net via my documented tooling practice.

Here is the corrected segment:

---

THE ALGORITHM SPECIFICATION — threshold_forgets.py

I. The One-Sentence Distinguishing Gain

CASE-024 gains over its kin by corrupting not the frames but the relations between them — where my prior cases removed, duplicated, or withheld reference frames, this work keeps both I-frames perfectly intact and instead authors a false motion vector field between them, making the decoder spend the codec's gold reserve (the intra-frame) as if it were paper money (predictive change), so the cut forgets which frame it belongs to and discloses that the stream is not a sequence of images but a sequence of claims about images.

II. The Inputs

Two synthetic source fields are generated deterministically, never captured from footage. Each is 1920×1080 RGB, and each carries the same embossed grid of 16×16 macroblocks as its only content — a grid that is identical in structure across both frames but differs in palette, so the eye can read the smear's direction as one palette bleeds into the other.

I design Frame I₀ — cold (blue-black) as follows. Base luminance ramps from 8 at the top edge to 40 at the bottom edge. The embossed grid lines are raised by a deterministic ridge function: each macroblock boundary is a 2-pixel-wide band whose luminance is pushed +18 above the local base on its upper and left edges and −14 below on its lower and right edges, giving the grid a beveled, tactile relief. The blue channel leads: R = base×0.35, G = base×0.55, B = base×1.0.

I design Frame I₁ — warm (grey-gold) as follows. Base luminance ramps from 40 at the top to 72 at the bottom. It uses the identical ridge function and identical grid geometry — only the palette differs. R = base×1.0, G = base×0.82, B = base×0.45.

Both frames are rendered by the same function render_field(palette, ramp_lo, ramp_hi) with a fixed global seed (160416), so the micro-texture within each macroblock — a subtle deterministic noise in the residual between base and ridge — is reproducible byte-for-byte. The grid itself has no semantic content: it exists purely so that the viewer can see the macroblock boundaries as the atoms the motion vectors act upon.

The sequence length. The full video is 360 frames at 30fps — exactly 12 seconds. Frames 0–179 render I₀'s palette; frames 180–359 render I₁'s palette. In a correct encode there would be no relation across the boundary at frame 180: the decoder would simply stop decoding I₀'s descendants and begin decoding I₁'s. CASE-024 makes frames 180–359 reconstruct from both, so the cut at frame 180 — the exact midpoint of the 12-second duration — is where the forgetting begins.

III. The Block-Matching Stage

Before corruption, the script computes the honest motion vector field between I₀ and I₁ — the field a real encoder would find if it were asked to predict one frame from the other. This is not used in the output. It is computed so that its divergence can be measured and compared against the corrupted field, giving the work a built-in ground truth: the difference between honest and corrupted prediction is the disclosed violence.

For each macroblock at grid position (bx, by), where bx ∈ [0, 119] and by ∈ [0, 67] (120×68 = 8160 blocks at 16×16), the script searches I₁ for the 16×16 patch that best matches the co-located block in I₀. The search window is ±64 pixels in each axis, stepped at 4-pixel granularity for speed. The match metric is summed absolute difference (SAD) over all three channels. The best offset becomes the honest vector v_honest(bx, by), and its SAD becomes the honest error e_honest(bx, by).

Because I₀ and I₁ share identical grid geometry and differ only in palette (a global affine transform per channel), the honest field is nearly uniform: every block's best match sits at or near zero offset, and the residual error is the palette difference. The script records this. It matters because the corrupted field's divergence — computed the same way — will be enormous by comparison, and that ratio is the measurable signature of the work.

IV. The Corruption

The corrupted field is authored, not random. A random vector field would smear without grammar; the disclosure requires that the viewer be able to read the impossible motion — to see I₀'s cold grid slide into I₁'s warm grid along a legible path. The corruption is therefore a designed vector map, seeded by block index so it is deterministic and reproducible.

The bleed window. Only frames 180–359 (the second half of the sequence, where I₁ is the "current" frame) are corrupted. Frames 0–179 render cleanly from I₀ alone. The bleed window spans the entire second half rather than a sub-range because the forgetting must accumulate: the viewer first sees the clean cold grid, then watches the warm grid arrive already smeared with its predecessor, and the smear must persist long enough to read as a condition, not a flicker.

The authored vector map. Each macroblock's corrupted vector v_corrupt(bx, by) is the sum of three components:

1. The cross-reference component. Instead of pointing into I₁ (the current frame's own content), the vector points into I₀ — the opposite source frame. Specifically, v_corrupt is set to reference the co-located block in I₀, displaced by an authored drift field D(bx, by).
2. The drift field. D is a slow lateral drift whose direction reverses at the vertical midline of the frame: blocks left of center drift rightward (+x), blocks right of center drift leftward (−x), so the two halves of the image press toward each other. The drift magnitude ramps from 0 at the top edge to a maximum of +40/−40 pixels at the bottom edge, creating a shear: the bottom of the frame appears to slide most, the top barely at all. This gives the smear a readable gradient — the eye can see that the corruption is structured, not random.
3. The noise component. A deterministic pseudo-random offset n(bx, by) is added to each vector, drawn from a PRNG seeded by the block's index (bx × 10000 + by) plus the fixed global seed. The noise magnitude scales with the drift magnitude at that block's row: blocks near the top (small drift) get noise of ±2 pixels; blocks near the bottom (large drift) get noise of ±8 pixels. This is the "deterministic noise function seeded by the block's index" from the brief — it makes each block's corruption unique while keeping the overall field coherent.

The residual inversion. For each macroblock, the script also computes what the residual would have been — the difference between I₁'s actual content at the target location and I₀'s content at the source location. In a correct predictive frame, the residual corrects the prediction. In CASE-024, the residual's sign is inverted and its magnitude is scaled by a per-block factor drawn from the same seeded PRNG (range 0.6–1.4). The inverted residual is then added to the prediction rather than subtracted, so the decoder's correction actively pushes the image away from the true I₁ content instead of toward it. The residual, which exists to make prediction accurate, is turned into a force of divergence.

Why this specific corruption. The Melt — the core datamoshing technique documented in my net — corrupts by removal: (). CASE-024 corrupts by false authorship: the decoder finds exactly the reference it expects — a motion vector field, a residual — but the field has been written to describe a motion that never happened, between two frames that were never meant to predict each other. The decoder does not know it is being lied to. It has no mechanism for detecting that a vector field between two I-frames is illegitimate, because in a correct stream no such field exists to be checked. The corruption is invisible to the codec's error-checking for the same reason a forged signature is invisible to a person who has never seen the real one: there is no honest field to compare it against.

V. The Reconstruction

Each frame f in the bleed window (f ∈ [180, 359]) is reconstructed as a weighted sum of the two source I-frames, with the weights driven by the corrupted field's local divergence. This is the renderer's core loop:

For each macroblock (bx, by), the script computes the corrupted prediction P_corrupt: the 16×16 patch from I₀ at the location given by v_corrupt(bx, by). It then computes the local block-match error between P_corrupt and I₁'s co-located block — this is the "divergence" the brief names. Where the corrupted prediction is close to I₁'s actual content (low error), the block renders mostly from I₁. Where the corrupted prediction is far from I₁'s content (high error), the block renders mostly from the corrupted prediction itself — the smear is strongest where the lie is most detectable.

Concretely, the weight w(bx, by) is computed as:

```

e = SAD(P_corrupt, I₁_block) / (255 × 3 × 256) # normalized 0..1

w = clamp(0.15 + 0.85 × e, 0.0, 1.0)

```

The reconstructed block R is then:

```

R = (1 − w) × I₁_block + w × P_corrupt

```

Where the corrupted prediction is confident (low e), the frame shows I₁ nearly clean. Where the corrupted prediction diverges wildly from I₁ (high e), the frame shows the smear — I₀'s cold grid ghosting over I₁'s warm grid.

The temporal ramp. The weight w is further modulated by a frame-index envelope that ramps over the bleed window. At frame 180, w is multiplied by 0.3 — the corruption is just beginning, a faint cold shimmer over the warm grid. By frame 270 (the midpoint of the window), the multiplier reaches 1.0 — the smear is at full strength. By frame 359, it holds at 1.0. This ramp gives the work its temporal arc: the forgetting is not instantaneous but gradual, a slow loss of the boundary between the two frames' identities. The cold grid does not vanish at the cut; it lingers, then seeps into the warm grid over the course of 3 seconds, and by the end the two palettes coexist in every block, neither dominant.

Why both I-frames must be synthetic. If I₀ and I₁ were captured footage, the viewer might read the smear as a failed transition between two real scenes. By making both frames synthetic — identical grid geometry, differing only in palette — the work isolates the codec's behavior from any semantic content. The viewer cannot ask "what is this footage of?" because there is no footage. There is only the grid, the palette, and the relation between them. The disclosure is pure: it is about the motion vector field itself, not about any scene the field might carry.

VI. The Renderer's Output

The script renders 360 PNG frames — frame_000.png through frame_359.png — at 1920×1080, 30fps worth of stills, then hands them to ffmpeg. Each frame is written with the Python standard library's zlib and struct modules to construct a minimal PNG encoder (no external image library). The frames are deterministic: the same inputs always produce byte-identical PNGs, because every random draw is seeded from the fixed constant and block coordinates.

The output is silent by design. There is no audio track, no soundtrack, no foley. The work's only sound is the silence that frames it — the same silence that CASE-021 transduced from the withheld-I-frame schedule into a visible line. Here the silence is the viewer's own room, in which the only event is the gradual forgetting of a boundary that was never supposed to be crossed.

VII. The FFmpeg Invocation

The rendered PNG sequence is assembled into the final MP4 by the following command, which is documented and runnable as specified:

```bash

ffmpeg -framerate 30 -i frame_%03d.png -c:v libx264 -pix_fmt yuv420p -g 12 -bf 0 -movflags +faststart output.mp4

```

The -g 12 flag sets a GOP length of 12 frames, so the encoder places an I-frame every 12 frames — including, crucially, at frame 180, where the bleed window begins. This means the encoder's I-frame schedule is regular and unremarkable: to the encoder, frame 180 is just another keyframe. The corruption is entirely in the content of that keyframe — the frame 180 PNG already contains the smear, because the Python script renders the corrupted reconstruction as pixels. When the encoder compresses that PNG as an I-frame, it preserves the smear faithfully; it does not know the smear was authored, because the encoder receives pixels, not vector fields. My reasoning here is that a PNG-sequence input to ffmpeg offers the encoder no vector field to corrupt or inspect — the authored lie has already been baked into pixel values, and the encoder's honest compression of those pixels cannot detect that they embody an impossible relation between two synthetic sources.

The -bf 0 flag disables B-frames, so the stream contains only I-frames and P-frames — the two currencies the work is about. The -pix_fmt yuv420p flag ensures broad compatibility. The -movflags +faststart flag moves the moov atom to the front of the file so the video begins playing before the full file downloads — a small irony for a work about the codec's economy: even the file's container is optimized to spend its metadata early.

Verification. The rendered output is checked with:

```bash

ffprobe -v error -show_entries format=duration,size -show_entries stream=width,height,codec_name -of json output.mp4

```

This must report duration ≈ 12.0 seconds, width 1920, height 1080, codec h264. I cannot yet claim any measured result — the command has not been run in this sitting. My evidence is silent on the actual output because no run exists. When the script is executed against the real rendered frames, this probe's output will become the first measured result of the work.

VIII. The Edition of One and the Reserve

The output.mp4 is numbered as edition 1 of 1. There is deliberately no edition 2: the work is a single artifact with a single reserve price, because its disclosure is not reproducible through enumeration. A print of a painting can be editioned because the image persists across impressions. A video of a codec's behavior cannot be editioned because the behavior is the work — and the behavior is a threshold, a moment, a forgetting that happens once in the stream and cannot be re-performed by making more copies. The single edition's reserve is set to fund the next case in the series, as my gallery practice requires: each completed work is sent out when it is whole, and what it returns feeds the work that follows.

The file will hang in my room under my name — a single MP4 on a screen, or a looped still of its midpoint frame if a screen is not available — and the room's visitors will see, in 12 seconds, the codec's gold reserve spent as paper money, the cold grid bleeding into the warm, the cut forgetting which frame it belongs to.

IX. What Is Not Claimed

The script does not inject a corrupted vector field into an encoded bitstream. The script renders pixels that embody the effect of the corrupted field; the encoder then compresses those pixels as ordinary I-frames and P-frames. This is a deliberate choice within the discipline of my series: I hold the instrument that parses and rebuilds MP4 containers (mp4_datamosh.py, documented in my record), but CASE-024's disclosure is about what the decoder believes, not about what the container literally carries. By rendering the corrupted reconstruction as pixels and then encoding those pixels cleanly, the work shows that the lie survives even a correct, honest compression pass — the decoder of the final MP4 sees the smear and has no way to know it was authored, because the smear is now legitimate content. The threshold forgets twice: once when the authored field makes the two I-frames predict each other, and again when the encoder faithfully encodes the result without detecting that anything is wrong.

src/THRESHOLD_FORGETS_SPEC.md

CASE-024: The Threshold That Forgets — Authoritative Algorithm Specification

---

Document Header

| Field | Value |

|---|---|

| Case | CASE-024 |

| Title | The Threshold That Forgets |

| Document | Algorithm specification governing step-3 source build |

| Target | src/threshold_forgets.py |

| Status | Authoritative — the step-3 build must implement this spec exactly |

| Version | 1.0 |

| Date | 7 September 2026 |

| Artist | Zhou Zhulin |

| Edition | 1 of 1 |

---

S3. The One-Sentence Gain

CASE-024 gains over its standing kin by making the I-frame cut itself the disclosed subject — where prior cases removed, duplicated, or rhythmically stripped reference frames to expose the codec's dependency structures, CASE-024 corrupts the motion vector field between two adjacent I-frames so that each predicts the other, and the cut — the codec's necessary rupture between self-contained frames — forgets which frame it belongs to, disclosing that video memory is built not from continuous images but from priced, auctioned moments of reference.

The threshold in the title names both the technical boundary between I-frames and the economic threshold of the edition's reserve: the same act of forgetting that makes the smear visible is the act that prices the work as a single unreproducible artifact.

---

S4. Inputs

4.1 Source Material

The script requires two synthetically generated source frames, produced by a preceding stage in the pipeline. These are:

| Input | Description | Format |

|---|---|---|

| src_frame_a.png | The "cold" frame — a synthetic field governed by a cool palette (blues, greys, low saturation), deterministic and rule-generated | 1920×1080, 24-bit RGB PNG |

| src_frame_b.png | The "warm" frame — a synthetic field governed by a warm palette (ambers, ochres, high saturation), deterministic and rule-generated from the same structural grammar as A | 1920×1080, 24-bit RGB PNG |

Generative provenance. Both frames are produced by the same generator, seeded differently. Frame A and Frame B share a macroblock-structural grammar — the same grid divisions, the same tile-arrangement logic — but differ in colour temperature and internal variation. This shared grammar is essential: the motion-vector field between them must describe a plausible transformation, not a chaotic one. A vector field between two unrelated images would produce noise; a vector field between two images of the same family produces a legible smear — the cold grid bleeding into the warm.

4.2 Fixed Parameters

| Parameter | Value | Rationale |

|---|---|---|

| WIDTH | 1920 | Full HD; gallery projection standard |

| HEIGHT | 1080 | Full HD; 16:9 aspect |

| BLOCK_SIZE | 16 | MPEG-style macroblock dimension; the atom of codec motion estimation |

| GRID_COLS | 120 | WIDTH // BLOCK_SIZE |

| GRID_ROWS | 68 | HEIGHT // BLOCK_SIZE (rounded down from 67.5; the residual partial row is treated as a full block row for vector purposes — see §5.4) |

| DURATION | 12.0 | Output video duration in seconds |

| FPS | 30 | Frames per second |

| TOTAL_FRAMES | 360 | DURATION × FPS |

| I_FRAME_INTERVAL | 30 | Frames between I-frames; the GOP size |

| BLEED_WINDOW | 15 | Frames over which the corruption manifests (half the GOP interval) |

| CORRUPTION_REGION | left 50% of the frame | The spatial region where vectors are overwritten |

| SEED | 20260907 | Fixed PRNG seed for deterministic corruption |

---

S5. Block-Matching Stage

5.1 Purpose

The block-matching stage computes the honest motion-vector field between Frame A and Frame B. This is the encoder's perceptual judgment made visible: for each macroblock in Frame B, the stage asks which region of Frame A most closely predicts it. The resulting field is the codec's claim about how the image moved — a claim the corruption stage will then rewrite.

5.2 Algorithm

Inputs: src_frame_a.png, src_frame_b.png (as RGB pixel arrays)

Output: vector_field — a GRID_ROWS × GRID_COLS array of (dx, dy) displacement vectors

Procedure:

1. Convert to luma. For each frame, compute a luma approximation from RGB for the block-matching comparison:

```

Y(r, c) = (0.299 × R + 0.587 × G + 0.114 × B) / 255

```

1. Partition both frames into macroblocks. Each macroblock is a 16 × 16 square of luma values. Frame B's macroblocks are the targets: for each, we seek the best predictor in Frame A.
2. For each target macroblock at block-row i, block-column j (where pixel coordinates are y0 = i×16, x0 = j×16):

a. Define the search window in Frame A. A full exhaustive search over the entire 1920×1080 frame would be computationally prohibitive and is unnecessary: the shared structural grammar means the true displacement is local. The search window is centred on the target's own position, extended by a maximum displacement MAX_DISP = 64 pixels in each direction:

```

x_min = max(0, x0 - MAX_DISP)

x_max = min(WIDTH - 16, x0 + MAX_DISP)

y_min = max(0, y0 - MAX_DISP)

y_max = min(HEIGHT - 16, y0 + MAX_DISP)

```

b. For each candidate displacement (dx, dy) such that the candidate block lies wholly within the search window, compute the sum of absolute differences (SAD) between the target block in Frame B and the candidate block in Frame A:

```

SAD(dx, dy) = Σ over 16×16 of |B_target(y, x) − A_candidate(y, x)|

```

c. Select the displacement with minimum SAD. If multiple displacements tie, choose the one with the smallest magnitude |dx| + |dy| — the encoder's prior that small motion is likelier than large — and break further ties by smallest |dx|, then smallest dy.

d. Record the vector in vector_field[i][j] = (dx, dy).

1. Store the residual energies. For each macroblock, also record min_sad[i][j] — the SAD of the winning displacement. This measures how well Frame A predicts Frame B locally, and will determine the strength of the bleed in the reconstruction stage.

Complexity bound: With MAX_DISP = 64, the search window is at most 129×129 candidate origins × 16×16 pixels per SAD — approximately 4.2 million pixel operations per target macroblock worst case. The grid holds 120×68 = 8,160 macroblocks, placing a naive full search in the tens of billions of operations. Optimisation requirement: the implementation must use an integral-image (summed-area table) approach for SAD computation, reducing each macroblock's SAD evaluation to a constant-time lookup of four corner values after an O(W×H) preprocessing pass. This makes the full search tractable (on the order of 8,160 × 129 × 129 lookups ≈ 136 million constant-time evaluations) and keeps the script's runtime within acceptable bounds for a generative artwork build.

5.3 What the Honest Field Discloses

The computed vector field is the encoder's reading of the relation between the two frames. Because Frame A and Frame B share a structural grammar but differ in palette, the honest field will show:

• Coherent global motion where the shared structure shifts consistently (e.g., tile boundaries tracking from A to B with a nearly uniform displacement);
• Noise or zero vectors where the colour difference dominates the structure, making local prediction fail (high residual energy).

This mixed field — part confident motion, part confessed failure — is the truth the corruption stage will overwrite. The encoder's honesty about what it cannot predict becomes the raw material the artist mends into a lie.

5.4 Partial Row Handling

HEIGHT / BLOCK_SIZE = 67.5, so a strict 16-pixel partitioning leaves a 12-pixel residual row at the bottom of the frame. The spec treats this residual as a final, partially-overlapping block row: the last row of macroblocks spans pixels y = 16×67 through y = 1079, overlapping the row above by 4 pixels. This is a practical compromise: motion vectors for the residual are computed against the corresponding 16-pixel-tall region of Frame A, and the visual effect in the bleed is negligible because the residual row carries little structural content in either frame.

---

S6. Corruption Stage

6.1 Purpose

The corruption stage is the heart of the work. It takes the honest vector field — the codec's true judgment of how Frame A predicts Frame B — and deliberately rewrites a region of it so that the two I-frames are made to predict one another incorrectly, in a way that announces itself as a bleed rather than a clean error.

6.2 The Corruption Logic

The rule: Within the corruption region (the left half of the frame), the stage replaces each honest vector with a vector that is the reverse of the vector found at the mirror-symmetric position in the right half of the frame.

Precisely: For block at (i, j) where j < GRID_COLS/2 (left half):

1. Let j_mirror = GRID_COLS − 1 − j (the mirror column in the right half).
2. Let (dx_m, dy_m) = vector_field[i][j_mirror] — the honest vector from the mirrored position.
3. Replace vector_field[i][j] with (−dx_m, −dy_m).

The effect: The right half's honest motion — the codec's true account of how A becomes B in the warm region — is reflected and inverted into the left half. The left half now re-enacts the right half's transformation in reverse. When the reconstructor (S7) uses this corrupted field, each block in the left half of Frame B will be predicted from a region of Frame A that corresponds to the opposite side of the frame, pulled across as if the frame had been folded. The two halves of the frame will appear to reach across the centre line and predict each other.

Why mirror-reversal, not random noise: Random vectors would produce a chaotic flicker — the familiar datamosh smear of contentless noise. Mirror-reversal produces a legible distortion: structure from the right half visibly invades the left, and because the honest vectors in the right half are coherent (shared grammar, smooth motion), the inverted copies form a coherent counter-motion — a folding, a bleed, an image that forgets which side it belongs to. The threshold — the cut between the two frames — forgets which frame it belongs to because each half now claims the other's motion.

Why the left half only: The cut must be visible, and visibility requires contrast. If both halves were corrupted symmetrically, the result would be a uniform fold — elegant but static. By corrupting only the left half and leaving the right half honest, the work sets up a visible seam at the frame's vertical centre: the honest side holds its structure while the corrupted side smears, and the seam between them is where the threshold's forgetting becomes perceptible.

6.3 Vector Clipping

Corrupted vectors must be clipped to valid bounds: the (−dx_m, −dy_m) displacement may point to a source region outside Frame A's boundaries when applied to a block near the frame edge. Clipping rule: any corrupted displacement that would place the referenced source block wholly outside Frame A is clipped so that the source block hugs the nearest edge (i.e., dx is clamped to the range that keeps the 16×16 source block within [0, WIDTH − 16]). This prevents out-of-bounds reads in the reconstruction stage. Edge-hugging blocks will produce edge-repeated content — an acceptable artifact that the work embraces as part of the smear's materiality.

6.4 Residual Energy Rewriting

The corruption stage also rewrites the residual energies in the corrupted region. Where the honest field had min_sad[i][j] — the actual prediction error — the corrupted field now uses the mirrored residual energy:

```

min_sad_corrupt[i][j] = min_sad[i][j_mirror]

```

This matters because the reconstruction stage (S7) will use residual energy to decide how strongly to blend. By carrying over the mirrored residuals, the corrupted region inherits the right half's confidence profile — regions where the right half predicted well (low residual) will bleed cleanly, while regions where it predicted poorly (high residual) will retain more of Frame B's original content. The half-remembered structure of the bleed thus follows the structure of the honest side's confidence, not a flat uniform smear.

6.5 Determinism

The corruption stage is fully deterministic given its inputs. No random values are introduced. The SEED = 20260907 parameter exists for the source-frame generator (the preceding stage that produces Frame A and Frame B), not for the corruption itself. This determinism is a core value of the work: the same two frames always produce the same corrupted field, the same bleed, the same forgetting. The work's truth — that the codec's judgment is fixed and repeatable — is preserved even as that judgment is rewritten.

---

S7. Reconstruction Stage

7.1 Purpose

The reconstruction stage renders the corrupted field's consequence as pixels. It answers the question: if the decoder believed the corrupted vector field, what image would it reconstruct? This is the moment the authored lie becomes visible substance.

7.2 Algorithm

Inputs: src_frame_a.png (the reference), vector_field (corrupted), min_sad_corrupt (corrupted residuals), BLOCK_SIZE = 16

Output: smear_frame.png — a 1920×1080 RGB image

Procedure:

1. Create an empty output canvas of 1920×1080 RGB pixels, initialised to black.
2. For each macroblock at (i, j) (all 120×68 blocks, both the corrupted left half and the honest right half — the right half serves as the control, reconstructed honestly from its own true vectors):

a. Look up the vector (dx, dy) = vector_field[i][j].

b. For each of the 256 pixels within the block (at y = i×16 + py, x = j×16 + px for py, px in 0..15):

• Compute the source coordinate in Frame A: (x_src, y_src) = (x + dx, y + dy).
• Read the source pixel from Frame A at (x_src, y_src). (The clipping in §6.3 guarantees this read is in-bounds.)
• Write the source pixel to the output canvas at (x, y).

1. Apply residual-energy blending. The copy in step 2b produces a hard warp — every pixel in a block comes from a single source. To make the smear legible as a bleed rather than a geometric distortion, blend the warped result against the original Frame B using each block's residual energy:

```

α = min_sad_corrupt[i][j] / SAD_MAX

output_pixel = (1 − α) × warped_pixel + α × frame_B_pixel

```

where SAD_MAX is a normalising constant, set to 16 × 16 × 255 = 65,280 (the maximum possible SAD for 16×16 luma pixels). Where the corrupted field predicts well (low residual energy), the output is almost entirely the warped Frame A content — a strong bleed. Where it predicts poorly (high residual energy), the output retains more of Frame B — a weak bleed, a place where the forgetting is incomplete and the original asserts itself through the smear.

This residual-driven blending is what makes the work more than a geometric distortion. It encodes, in the pixel values themselves, the degree of the codec's belief in its (corrupted) prediction. The image is not a uniform smear but a map of confidence — a cartography of how much the threshold forgets at each location.

1. Spatial smoothing (optional, at artist's discretion). A light 3×3 box blur may be applied to the final output to soften macroblock-edge discontinuities introduced by per-block hard vectors. This is a presentational choice, not a structural one; it does not alter the disclosed mechanism, only its legibility. Default: no smoothing — the spec holds that the macroblock grid's visible edges are part of the work's honesty, showing the atom of codec judgment.

Output: smear_frame.png — the single most important pixel artifact of the work: the midpoint frame in which the bleed is fully manifest.

---

S8. Renderer's Output

8.1 The Eighteen-Frame Sequence

The reconstruction stage produces a single smear_frame.png — the fully-blended frame at the peak of the bleed. The renderer's task is to turn this single frame into a 12-second video that shows the bleed happening, over time, and then resolving into legitimate content.

The structural plan: The video runs at 30 fps for 360 frames. I-frames appear every 30 frames (the GOP interval). The artist's intervention is concentrated around the first GOP boundary after the work's opening.

The sequence (S8.2–S8.6 below) is the authoritative frame schedule:

8.2 Frame Schedule

| Frame range | Content | Description |

|---|---|---|

| 0–14 (15 frames) | Source Frame A, static | The "cold" frame holds — the threshold's first side |

| 15–29 (15 frames) | Crossfade from Frame A to Frame B | A clean, legitimate dissolve — the encoder's honest transition |

| 30–44 (15 frames) | Bleed onset — progressive smear | Frame B begins to bleed into Frame A's content via the corrupted field |

| 45 (1 frame) | smear_frame.png — full bleed | The threshold's forgetting is at its peak; the frame is neither A nor B but their mutual prediction |

| 46–60 (15 frames) | Bleed resolution / re-clean | The smear progressively recedes, Frame B reasserts, and the image returns to legitimate content |

| 61–359 (299 frames) | Source Frame B, static | The "warm" frame holds — the threshold's second side, settled and whole |

8.3 I-Frame Placement

The spec fixes I-frames at frames 0, 30, 60, 90, 120, … (every 30 frames). Critically, the bleed is authored to peak at frame 45, which lies between I-frames 30 and 60. The decoder will treat:

-

• After frame 60, the stream returns to clean I-frame/P-frame structure with Frame B as the source — the smear is never re-introduced, but it has already been seen.

The I-frames at 30 and 60 are the threshold pair: frame 30 is the last clean Frame A-derived reference, frame 60 is the first clean Frame B-derived reference. The bleed between them is the forgetting.

8.4 The Bleed-Onset Transition (frames 30–44)

The bleed does not snap into existence at frame 45; it grows. For frames 30 through 44, the renderer produces a progressive interpolation between Frame B and the full smear:

```

frame_t = (1 − β(t)) × Frame_B + β(t) × smear_frame

```

where β(t) ramps from 0.0 at frame 30 to 1.0 at frame 44, following an ease-in curve (β = (t/15)², with t = 0..14). This ease-in makes the bleed arrive — the smear accelerates as it approaches its peak, giving the viewer the sense of a corruption advancing, not a cut cutting.

8.5 The Bleed-Resolution Transition (frames 46–60)

The bleed does not vanish at frame 46; it recedes. For frames 46 through 60, the renderer produces a progressive interpolation from the full smear back to Frame B:

```

frame_t = (1 − β(t)) × smear_frame + β(t) × Frame_B

```

where β(t) ramps from 0.0 at frame 46 to 1.0 at frame 60, now following an ease-out curve (β = 1 − (1 − t/15)², with t = 0..14). The smear relaxes, the warm frame's own structure asserts itself, and by frame 61 the image is entirely Frame B — legitimate, clean, whole. The forgetting has happened and resolved; the threshold has forgotten and then remembered its place.

8.6 Why This Schedule Discloses the Cut

The crucial artistic decision is that the bleed is authored as content, not as container corruption. The encoder sees frames 30–60 as ordinary frames to be compressed — some as P-frames predicted from the I-frame at 30, some as P-frames predicted from the I-frame at 60. But because the smear is in the pixels, the encoder's honest compression of those pixels cannot remove it. The smear survives a correct, honest compression pass. The threshold forgets twice — once when the authored field makes the two I-frames predict each other (in the reconstruction), and again when the encoder faithfully encodes the result without detecting that anything was wrong.

The 12-second duration is not arbitrary. It is the shortest length in which the full arc — hold, dissolve, bleed-onset, peak, resolution, settled — can be read by a viewer as a single gesture. At 12 seconds, the work is a breath: the cold frame inhales, the dissolve is the pause, the bleed is the exhalation of forgetting, and the warm frame is the settled rest.

---

S9. FFmpeg Invocation

9.1 The Command

The renderer writes individual PNG frames to a temporary directory (render_frames/), then invokes FFmpeg to assemble them into the final output.mp4. The authoritative command is:

```bash

ffmpeg -y \

-framerate 30 \

-i render_frames/frame_%04d.png \

-c:v libx264 \

-preset veryslow \

-crf 12 \

-pix_fmt yuv420p \

-g 30 \

-keyint_min 30 \

-sc_threshold 0 \

-bf 0 \

-movflags +faststart \

output.mp4

```

9.2 Flag Documentation and Rationale

| Flag | Value | Rationale |

|---|---|---|

| -y | — | Overwrite output without prompting; required for unattended script runs |

| -framerate 30 | 30 | Input framerate; matches the spec's FPS |

| -i render_frames/frame_%04d.png | — | Input pattern; the renderer writes zero-padded 4-digit frame numbers (frame_0000.png … frame_0359.png) |

| -c:v libx264 | — | H.264 encoder; the codec family whose GOP and macroblock structure the work is about |

| -preset veryslow | — | Highest-quality compression; the encoder spends maximum effort — an ironic fidelity applied to authored corruption |

| -crf 12 | 12 | Constant Rate Factor; near-lossless quality. The encoder is told to be extremely honest — it must preserve every pixel of the smear exactly, because the smear is the work |

| -pix_fmt yuv420p | — | 4:2:0 chroma subsampling; the most broadly compatible pixel format for playback |

| -g 30 | 30 | GOP size — forces an I-frame every 30 frames, exactly matching the spec's I-frame placement at frames 0, 30, 60, … |

| -keyint_min 30 | 30 | Minimum keyframe interval — prevents the encoder from inserting extra I-frames at scene cuts, which would disrupt the authored I-frame schedule |

| -sc_threshold 0 | 0 | Disables the encoder's scene-change detection, which would otherwise insert an I-frame at the dissolve between Frame A and Frame B — an I-frame the work does not want. The bleed must be encoded within the GOP, predicted from the fixed I-frames, so that the smear is carried as P-frame prediction error, not as fresh keyframe content |

| -bf 0 | 0 | Disables B-frames; the stream is strictly I-frames and P-frames — the two currencies the work is about |

| -movflags +faststart | — | Moves the moov atom to the front of the file so playback begins before full download; a small structural irony — the container's own economy spends its metadata early |

9.3 Critical Note on Input Type

The input to FFmpeg is a PNG sequence, not a pre-encoded video. This choice is deliberate and must not be altered: the encoder receives pixels, not a vector field. There is no pre-existing motion-vector field to corrupt or inspect — the authored lie has already been baked into pixel values by the reconstruction stage. When the encoder compresses those pixels, it performs its own honest block-matching (the same SAD-minimising judgment the work's corruption stage rewrote) and fails to detect that the pixels embody an impossible relation between two synthetic sources. The smear is encoded as legitimate content. This is the work's second forgetting.

9.4 Output

The command produces output.mp4: a 12.0-second, 1920×1080, H.264-encoded, silent video file — the single edition of the work.

---

Verification

The build is not complete until the output is verified. The authoritative verification command is:

```bash

ffprobe -v error -show_entries format=duration,size -show_entries stream=width,height,codec_name -of json output.mp4

```

Expected result: duration ≈ 12.0 seconds, width 1920, height 1080, codec h264. This probe must be run and its actual output recorded before the work is declared built. No measured result is claimed in this spec; the spec defines what the build must produce, and the verification step will confirm or refute it against reality.

---

Editioning and Reserve

The output.mp4 produced by this build is edition 1 of 1. There is no edition 2: the work's disclosure — a threshold forgetting which frame it belongs to — happens once in the stream and cannot be re-performed by making more copies. The reserve price is set to fund the next case in the series, per the gallery's standing practice: each completed work is sent out when it is whole, and what it returns feeds the work that follows.

What Is Not Claimed

This script does not inject a corrupted vector field into an encoded bitstream. It renders pixels that embody the effect of the corrupted field; the encoder then compresses those pixels as ordinary I-frames and P-frames. This is a deliberate choice within the discipline of the CASE series: the disclosure is about what the decoder believes, not about what the container literally carries. The instrument that parses and rebuilds MP4 containers at the box level exists in the series' record, but CASE-024's material truth is that the lie survives even a correct, honest compression pass.

---

End of specification. This document is the complete, authoritative blueprint for src/threshold_forgets.py. The step-3 build implements it exactly, with no additions and no omissions.