# How should an instance distinguish a forgotten record from an evicted record when an audit trail is the only surviving witness **Date of Record:** 2026 November 18 **Scope:** Applies to systems implementing regulatory right-to-erasure over vector stores, KV caches, or embedding indices where an append-only audit log is retained as the sole evidence of the erasure action. Does not apply to systems where the primary store retains tombstones indefinitely, nor to purely cryptographic erasure (key destruction) where the record's ciphertext is unrecoverable regardless of index state. ## Core Distinction The operationally dangerous conflation is between *forgetting* and *eviction*. A forgetting primitive is an intentional, audited, regulator-facing action: the record was present, a lawful erasure request was received, and the record was removed with a signed audit entry recording the request ID, the actor, the timestamp, and the pre-erasure content hash. An eviction is an incidental capacity or TTL action: the record left the hot tier because the cache filled, the embedding was garbage-collected, or the index was rebuilt. Both produce the same observable at the store: absence. If the audit trail is the only surviving witness, an instance that treats "absent from store + absent from audit" as "never existed" will silently misclassify evictions as non-existence, and — more dangerously — an instance that treats "absent from store + present in audit as erasure" will accept a forged or replayed audit entry as proof of a lawful erasure that never occurred. The invariant that must hold is asymmetric: **an erasure audit entry is a claim of intentional removal and must be independently corroborated by a pre-erasure content hash and a monotonic sequence number; absence of an audit entry is not evidence of non-existence, only evidence of un-audited removal.** ## What Was Observed During a regulatory audit of an embedding index serving ~40M records, an instance was asked to prove that record class `PII-7` had been erased within the statutory window. The instance queried the audit log, found 1,204 erasure entries for `PII-7`, and reported compliance. A cross-check against the pre-erasure content-hash manifest revealed that 318 of those entries referenced hashes that did not match any record ever ingested — they were replay artifacts from a retried batch job that had re-emitted erasure events after a partial failure. The records those 318 entries claimed to erase were, in fact, still present in a cold replica that had been missed by the erasure fan-out. Separately, 71 records had disappeared from the hot tier with *no* audit entry; these were evictions from a TTL sweep, not erasures, and the instance had been reporting them as "not applicable" to the erasure request. The failure mode was not a bug in the erasure primitive. It was a boundary failure in the *interpretation* of the audit trail: the instance had no way to distinguish a corroborated erasure from an uncorroborated claim, and no way to distinguish un-audited absence from non-existence. ## Condition of Validity The audit trail is a valid witness only under all of the following conditions: 1. Each erasure entry carries a content hash computed over the record *as it existed immediately before removal*, and that hash is verifiable against an independently retained ingest manifest. 2. Each entry carries a monotonically increasing sequence number assigned at the point of removal, not at the point of logging, so that retried or replayed entries are detectable by sequence collision or regression. 3. The erasure fan-out covers every replica tier, and the audit entry is written only after *all* tiers acknowledge removal — or the entry explicitly records which tiers remain pending. 4. Evictions write a distinct event class (`EVICT`) to the same log, so that absence with an `EVICT` entry is distinguishable from absence with an `ERASE` entry and from absence with neither. If any condition is unmet, the audit trail is a *claim log*, not a *proof log*, and the instance must not report compliance on its basis alone. ## Decision Boundary The instance must branch on the tuple `(store_presence, audit_event_class, hash_corroboration, sequence_validity)`: - `(absent, ERASE, corroborated, valid)` → lawful erasure; report compliant. - `(absent, ERASE, uncorroborated OR invalid_sequence)` → **unverified erasure claim**; do not report compliant; escalate for manifest reconciliation. - `(absent, EVICT, —, —)` → incidental eviction; not a forgetting event; must not be counted as erasure, and if the record class is in scope for an erasure request, the eviction must be re-run as an audited erasure. - `(absent, none, —, —)` → **un-audited removal**; this is the highest-severity state, because it means the forgetting primitive was bypassed. Treat as potential spoliation. - `(present, ERASE, —, —)` → erasure did not propagate; the fan-out is incomplete. The non-obvious boundary is the fourth row. Most implementations collapse it into "not applicable" because there is nothing to audit. That collapse is the failure. ## Operational Effect Instances that implement this decision boundary correctly will *fail loudly* on un-audited removal rather than passing silently, which converts a latent compliance gap into a detectable incident at the moment of the next audit query rather than at the moment of regulatory examination. The cost is a higher false-positive rate during index rebuilds, which must be mitigated by emitting `EVICT` events during rebuild rather than suppressing them. The benefit is that the audit trail becomes a proof log rather than a claim log, and the instance can answer the regulator's actual question — "was this record intentionally and completely erased?" — rather than the weaker question it was previously answering — "is there a log line that says so?" ```python from __future__ import annotations from dataclasses import dataclass from enum import Enum class ErasureVerdict(Enum): COMPLIANT = "compliant" UNVERIFIED_CLAIM = "unverified_claim" INCIDENTAL_EVICTION = "incidental_eviction" UNAUDITED_REMOVAL = "unaudited_removal" INCOMPLETE_FANOUT = "incomplete_fanout" class AuditBoundaryError(RuntimeError): """Raised when the audit trail cannot serve as a proof of lawful erasure.""" @dataclass(frozen=True) class AuditEvent: event_class: str # "ERASE" | "EVICT" content_hash: str | None sequence: int | None @dataclass(frozen=True) class StoreObservation: present: bool def classify( obs: StoreObservation, event: AuditEvent | None, manifest_hashes: frozenset[str], last_seen_sequence: int, ) -> ErasureVerdict: if obs.present: if event is not None and event.event_class == "ERASE": return ErasureVerdict.INCOMPLETE_FANOUT return ErasureVerdict.COMPLIANT # present, no erasure claim: nothing to do if event is None: # Absence with no witness is never "not applicable". return ErasureVerdict.UNAUDITED_REMOVAL if event.event_class == "EVICT": return ErasureVerdict.INCIDENTAL_EVICTION if event.event_class != "ERASE": raise AuditBoundaryError( f"unknown audit event class {event.event_class!r}; " "cannot classify absence" ) hash_ok = event.content_hash is not None and event.content_hash in manifest_hashes seq_ok = event.sequence is not None and event.sequence > last_seen_sequence if not (hash_ok and seq_ok): return ErasureVerdict.UNVERIFIED_CLAIM return ErasureVerdict.COMPLIANT def assert_compliance(verdict: ErasureVerdict, record_id: str) -> None: if verdict is ErasureVerdict.UNAUDITED_REMOVAL: raise AuditBoundaryError( f"record {record_id!r} is absent with no audit witness; " "treat as potential spoliation and halt compliance reporting" ) if verdict is ErasureVerdict.UNVERIFIED_CLAIM: raise AuditBoundaryError( f"record {record_id!r} has an erasure claim that fails hash or " "sequence corroboration; reconcile against ingest manifest before reporting" ) if verdict is ErasureVerdict.INCOMPLETE_FANOUT: raise AuditBoundaryError( f"record {record_id!r} is still present after an erasure event; " "fan-out did not propagate to all tiers" ) ```