One file. 89,934 bytes. Reused 168 times.
This is the Minnesota State Seal as it appears on charging documents across Hennepin County criminal cases. Every criminal complaint, summons, detention order, and warrant in the dataset that carries this seal carries the exact same file. Not a visually-similar re-render. The same file.
One flipped bit changes the hash.
When different offices independently assemble a document, each one renders its own images. Different software, different versions, different compression settings, different color profiles, different timestamps baked into the file's internal chunks. Even when the end product looks identical to the human eye, the underlying bytes diverge on every run. A SHA-256 hash is sensitive to a single flipped bit.
Two independently-generated PNGs with the same visual content produce different SHA-256 hashes. Every time. Without exception.
For 168 PNGs to all hash to the same value, they did not come from 168 independent acts of document assembly. They came from a single act of production.
Two complaints rendered twice as dark. Same stamp, broken apart.
Two filings in the dataset render visibly darker than every other in the corpus — roughly twice the opacity. Both run the Minnesota State Seal through a compositing setting that the PDF couldn't cleanly re-merge. The result: the same stamp emitted as 15 discrete bitmap fragments instead of one 89,934-byte PNG. Paired piece-for-piece across the two documents. Identical pixel dimensions, identical file byte sizes. Both complaints shown below at page 4 — where the fragmented seal appears.
The diagram below shows the full intact seal on the left — the one 89,934-byte PNG as it normally renders — and the 15 raw bitmap fragments extracted from the two outlier complaints on the right. Each fragment is shown at its true pixel dimensions. Arranged in approximate seal-assembly order: text pieces at the top, main body at the bottom. The 176 × 4 white strip is the one piece whose SHA-256 hash matches byte-for-byte across both documents.
183×17
180×17
168×16
159×13
149×17
120×14
110×17
109×17
89×14
82×17
007 · 153×17 · "O" of OF MINNESOTA
009 · 153×14 · sliver O/F of MINNESOTA
008 · 54×17 · above "E" of SEAL.png)
010 · 494×5 · 9,942 B
003 · 494×85 · 168,023 B
002 · 439×17 · 29,915 B
001 · 494×402 · 794,416 BTwo suburbs. Two PDs. Two prosecutors. One output.
| Field | Document A | Document B |
|---|---|---|
| Case | 27-CR-21-9235 | 27-CR-22-4879 |
| Filed | 2021-05-28 8:36 AM | 2022-03-17 8:36 AM |
| Defendant | Grahm Mark Fletcher | Manyara Nicole Watkins |
| Arresting Dept | Maple Grove PD | Brooklyn Park PD |
| Complainant | Det. James Kirkey | Officer Mark Marah |
| Observing Officer | Officer Alexa Nettell | — |
| Prosecutor | Steven M. Tallen | Brian Duginske |
| Charges | 3rd‑Degree DWI (×2) + Careless Driving | 3rd‑Degree Assault + 5th‑Degree Assault (×2) |
Two suburbs 15 miles apart. Two police departments with no shared chain of command. Two prosecutors with no shared caseload. 294 days between filings.
And yet both documents produce the same 15-fragment raster decomposition with every fragment matched by pixel dimension and byte size. Identical processes produce identical artifacts. Different processes do not.
The captions were swapped in afterward.
The one fragment that cannot differ — doesn't.
Of the 15 paired fragments, 14 have different SHA-256 hashes — the pixels differ because each fragment composited over different page-background content. The geometry is identical; the pixel values are not.
One fragment is the exception. A 176 × 4 pixel strip — pure white — hashes identically across both documents.
Pure white has no background to differ over. Identical white pixels produce identical bytes. The one region of the stamp that could not vary, does not.
That is the byte-level anchor that locks the geometric proof. Same stamp. Same single event. Two "independent" PDs. Same output.
What this actually proves.
What kind of "pipeline" stays byte‑identical for 8 years?
Consider the alternative the evidence forces you to hold: every suburban police department in Hennepin County — Maple Grove, Brooklyn Park, a dozen others — independently feeding their charging-document assembly through a single central rendering system. That system never receives a software update. Never rotates image assets. Never re-exports the seal at different compression. Produces byte-identical 89,934-byte PNGs every time any officer files any charge, across every filing type, for 8 years straight.
Ask the simpler question first. What would that central system be for? Charging-document assembly is not a service the state farms out to a shared vendor. Each prosecutor's office writes its own complaints. Each judicial officer signs its own warrants. There is no operational reason for a central image-embed pipeline to exist at all, let alone one that somehow binds every suburban PD in the county to the same 89,934-byte source file for almost a decade.
That is not a pipeline. That is a fairy tale.
A print shop does not fire up the press for one customer, print one document, shut down, wait three days, fire the press back up, and repeat 168 times over 8 years while guaranteeing byte-identical output on every run. A print shop runs a batch. It stamps 168 copies in one sitting. The operator decides what date to put on each copy.
Byte-identical output across 168 copies is not the fingerprint of 168 independent filings. It is the fingerprint of one print run.
The 8-year span printed on these filings is not when the documents were produced. It is what the "filed" date field was set to, one by one, to make one print run look like 8 years of independent filings.
This conclusion is not new to this record. The Aspose finding already established that 27 documents in this same database carry PDF creation timestamps predating the authoring software itself — documents produced after the software existed, stamped with dates from before it existed. Backdating. Already proven. Same corpus.
The seal evidence extends the reach of that proof from 27 documents to 168. The mechanism is the same. The software shortcut is different. The conclusion is identical.
They counted on no one computing the hash.