Wasure: Forgetting and Memory Governance

• Wasure is a term that encompasses multiple strategies in machine learning and logic, focusing on selective forgetting and adaptive memory governance.
• It includes techniques such as bounded Hebbian memory, differentiable working memory, and gradient-based unlearning to balance privacy and utility.
• The term also names a versatile WebAssembly benchmarking toolkit, illustrating its semantic diversity and interdisciplinary relevance.

In current arXiv usage, Wasure denotes a heterogeneous cluster of technical ideas centered on forgetting, selective erasure, and memory governance, rather than a single algorithm or formalism. In machine learning, forgetting is explicitly described as the Japanese term wasure and refers to deliberate modification of a model’s internal state so that past data or learned parameters lose influence on future predictions (Sha et al., 2024). The term also appears in analyses of bounded Hebbian memories (Marinari, 2018), differentiable working-memory control (Jayram et al., 2018), machine unlearning and forgetting audits (Cheng et al., 2024, Liu et al., 2020, Sun et al., 2024, Koh et al., 20 Apr 2026, Jawandhia et al., 2 Jun 2026), formal forgetting in logic and Answer Set Programming (ASP) (Doherty et al., 2023, Gonçalves et al., 2017), and, in a distinct sense, as the name of a modular WebAssembly benchmarking toolkit (Carissimi et al., 5 Feb 2026).

1. Terminological scope and major usages

A common misconception is that Wasure names a single unlearning method. In the cited literature, it instead labels several technically distinct objects that share a concern with removing, attenuating, suppressing, or governing memory-like influence.

Usage in the literature	Core object	Representative source
Adaptive forgetting in ML	Deliberate reduction of past-data influence	(Sha et al., 2024)
Exponential forgetting in associative memory	Bounded Hebbian memory with age-dependent retrieval loss	(Marinari, 2018)
Controlled forgetting in neural memory	Erase/add external-memory architecture	(Jayram et al., 2018)
Machine unlearning	Approximate or selective removal of training-data effects	(Cheng et al., 2024, Koh et al., 20 Apr 2026, Jawandhia et al., 2 Jun 2026, Sun et al., 2024)
Auditing whether forgetting occurred	Statistical test based on shadow models and K-S distances	(Liu et al., 2020)
Logical forgetting	Standard and weak forgetting operators	(Doherty et al., 2023)
Forgetting in ASP	Relaxations of strong persistence	(Gonçalves et al., 2017)
WebAssembly benchmarking toolkit	Modular CLI system named “Wasure”	(Carissimi et al., 5 Feb 2026)
Agent memory governance	Two-counter Memory Worth signal for suppression or deprecation	(Simsek, 13 Apr 2026)

This breadth suggests that Wasure functions less as a discipline-specific term of art than as a recurring label for operations that determine what information should cease to affect future computation.

2. Associative-memory formulations and exponential forgetting

In the survey literature, forgetting is defined as “any deliberate modification of a model’s internal state so that past data or learned parameters lose influence on future predictions” (Sha et al., 2024). That framing is instantiated sharply in the bounded Hebbian model studied by Marinari, which revisits the memory “which forgets,” introduced by Parisi in 1986 (Marinari, 2018). The update rule is a Hebb-like increment followed by hard clipping:

$$w_{ij}(t+1)=\mathrm{clip}\!\left(w_{ij}(t)+\frac{1}{N}\xi_i^\mu \xi_j^\mu,\,-A,\,A\right).$$

Here $w_{ij}(t)$ is the synaptic strength from neuron $j$ to $i$, $N$ is the number of binary neurons $\sigma_i\in\{\pm1\}$, $\xi_i^\mu\in\{\pm1\}$ is the $i$-th bit of pattern $\mu$, and $A>0$ is the saturation threshold of synaptic efficacy (Marinari, 2018).

The model’s motivation is confusion avoidance. In the classical Hopfield model, presenting too many patterns with $w_{ij}(t)$0 yields catastrophic interference; with saturation at $w_{ij}(t)$1, conflicting contributions cannot accumulate without bound, so new patterns overwrite older ones and the network remains able to learn recently presented inputs (Marinari, 2018). Numerical studies show that, for optimal $w_{ij}(t)$2, the maximal fraction of recognized patterns is

$w_{ij}(t)$3

with critical bound

$w_{ij}(t)$4

in good agreement with the analytical result $w_{ij}(t)$5 from van Hemmen–Keller–Kühn (1988) (Marinari, 2018).

The large-$w_{ij}(t)$6 behavior is especially important. With $w_{ij}(t)$7, $w_{ij}(t)$8, and $w_{ij}(t)$9 fixed, patterns presented $j$0 steps before the current time are retrieved with probability tending to $j$1 when $j$2 and $j$3 when $j$4, with $j$5 asymptotically; only the most recent $j$6 patterns are retrievable (Marinari, 2018). The basin of attraction $j$7, defined as the probability that a random initial state converges under zero-temperature steepest-descent dynamics to a pattern of age $j$8, obeys

$j$9

and $i$0 versus $i$1 is nearly linear over more than five decades (Marinari, 2018).

Marinari identifies this exponentially collapsing basin as “a clearly non physiological feature of the model” (Marinari, 2018). The paper further notes that true biological memory does not exhibit an unrelenting exponential decay of accessibility with age, and that a model requiring nearly continuum-valued synapses while real synapses have only “$i$2 distinguishable states” is difficult to reconcile with experimental plasticity time-courses (Marinari, 2018). This establishes an enduring distinction within wasure research: forgetting can be computationally stabilizing while still being biologically implausible.

3. Differentiable working memory and memory governance

A second line of work treats forgetting not as passive decay but as active control. The Differentiable Working Memory (DWM) model is an RNN controller plus a small external memory buffer, trained end-to-end to emulate human working memory rather than episodic storage (Jayram et al., 2018). Its defining properties are limited capacity, sequential access, and manipulation capability: the controller can selectively retain, overwrite, or erase items.

At each time step, DWM reads from memory, updates the controller state, edits memory through an erase-plus-add operation, and shifts the focus of attention. The memory edit is

$i$3

where $i$4 is the learned erase vector and $i$5 the add vector (Jayram et al., 2018). Bookmarks $i$6 store prior attention patterns, allowing the controller to return its focus to previous locations. The erase mechanism is explicitly differentiable: when $i$7 in feature dimension $i$8, the content at the addressed locations is zeroed out (Jayram et al., 2018).

No explicit forget-penalty regularizer is required. According to the paper, task structure itself drives controlled forgetting: in the “Ignore” task, recalling distracting subsequences is penalized; in the “Forget” task, the model must reproduce $i$9 immediately but later recall only the $N$0 (Jayram et al., 2018). DWM learned to skip writing irrelevant $N$1 or overwrite or erase it immediately after reproducing it. In limited-memory regimes, it discovered a two-mode strategy in which attention freezes on $N$2-subsequences and advances on $N$3-subsequences, reducing memory footprint (Jayram et al., 2018).

The quantitative comparison is striking. LSTM with more than $N$4 million parameters and DNC with approximately $N$5K parameters either failed entirely or did not generalize beyond sequence lengths of about $N$6, whereas DWM with $N$7 parameters generalized perfectly to length $N$8, two orders of magnitude longer than the training sequences (Jayram et al., 2018). In this usage, wasure denotes learned selectivity in addressable memory rather than irreversible deletion.

A related but operationally different formulation appears in agent memory governance. “When to Forget: A Memory Governance Primitive” introduces Memory Worth (MW), a two-counter signal per memory unit that tracks weighted co-occurrence with successful and failed outcomes (Simsek, 13 Apr 2026). For memory $N$9, the counters are

$\sigma_i\in\{\pm1\}$0

and

$\sigma_i\in\{\pm1\}$1

Under stationarity, exploration, conditional independence, bounded outcomes, minimum weight, and outcome stationarity, $\sigma_i\in\{\pm1\}$2 almost surely, where $\sigma_i\in\{\pm1\}$3 (Simsek, 13 Apr 2026).

The paper is explicit that $\sigma_i\in\{\pm1\}$4 is associational rather than causal. Nevertheless, after $\sigma_i\in\{\pm1\}$5 synthetic episodes the Spearman rank-correlation between Memory Worth and true utilities reaches $\sigma_i\in\{\pm1\}$6 across $\sigma_i\in\{\pm1\}$7 independent seeds, compared to $\sigma_i\in\{\pm1\}$8 for systems that never update their assessments (Simsek, 13 Apr 2026). In a retrieval-realistic micro-experiment using all-MiniLM-L6-v2, stale memories cross the low-value threshold at $\sigma_i\in\{\pm1\}$9 while specialist memories remain high-value at $\xi_i^\mu\in\{\pm1\}$0 across $\xi_i^\mu\in\{\pm1\}$1 episodes (Simsek, 13 Apr 2026). This extends wasure from deletion or erasure to ongoing governance over whether a memory should be trusted, suppressed, or deprecated.

4. Machine unlearning, selective forgetting, and forgetting audits

The survey on forgetting organizes machine forgetting along the dimensions of content of forgetting, recoverability, and extent of erasure, while also distinguishing Active from Passive methods (Sha et al., 2024). Item-level, feature-level, class-level, task-level, and stream-level forgetting are all recognized; forgetting may be irrecoverable or recoverable, exact or approximate (Sha et al., 2024). This taxonomy is useful because most concrete wasure systems occupy only one region of that design space.

A recent token-level selective-unlearning method is Entropy-guided Token Weighting (ETW). Large-language-model unlearning is posed as an update combining retain loss and forget loss,

$\xi_i^\mu\in\{\pm1\}$2

where the forget objective uses per-token weights $\xi_i^\mu\in\{\pm1\}$3 (Koh et al., 20 Apr 2026). ETW defines token entropy

$\xi_i^\mu\in\{\pm1\}$4

with $\xi_i^\mu\in\{\pm1\}$5 a stop-gradient copy of $\xi_i^\mu\in\{\pm1\}$6, and sets

$\xi_i^\mu\in\{\pm1\}$7

The method is motivated by the observation that informative tokens tend to have higher entropy, whereas structural tokens tend to have lower entropy (Koh et al., 20 Apr 2026). On TOFU and WMDP across $\xi_i^\mu\in\{\pm1\}$8B, $\xi_i^\mu\in\{\pm1\}$9B, and $i$0B models, ETW achieves the highest ROC-AUC, approximately $i$1, for separating human-annotated informative tokens from structural tokens, and yields the lowest aggregated score on the TOFU $i$2 forget split while also reducing forget-set accuracy more than comparators at equal retained-set MMLU accuracy in WMDP (Koh et al., 20 Apr 2026).

A different approach is MU-Mis, which treats a sample’s contribution to learning as reflected in the learned model’s input sensitivity (Cheng et al., 2024). The unlearning loss for a forget sample $i$3 of class $i$4 compares the target-class Jacobian norm with that of an irrelevant class $i$5: $i$6 The method minimizes the sum of this quantity over the forget set and does so without using the remaining data during unlearning (Cheng et al., 2024). On CIFAR-100 full-class forgetting for “rocket,” MU-Mis obtains $i$7, $i$8, and $i$9, close to Retrain’s $\mu$0, $\mu$1, and $\mu$2, while being $\mu$3–$\mu$4 faster than full retraining when $\mu$5 (Cheng et al., 2024).

PURGE explicitly exploits the duality between continual learning and machine unlearning. It projects forget gradients against retain gradients so that each step does not increase retain-set loss, adds multi-layer representation erasure, and replaces a uniform unlearning target with a retain-confusion target (Jawandhia et al., 2 Jun 2026). If $\mu$6, the forget gradient is replaced by

$\mu$7

The representation-erasure term averages $\mu$8 over intermediate layers, and automatic stopping uses a retain-loss budget and a forget-accuracy target (Jawandhia et al., 2 Jun 2026). Across CIFAR-10, MNIST, SVHN, STL10, and PathMNIST, PURGE “consistently keeps retain accuracy above 96% while achieving MIA AUROC close to 0.5”; on CIFAR-10 class-0 forgetting it reports $\mu$9, $A>0$0, $A>0$1, and $A>0$2 (Jawandhia et al., 2 Jun 2026).

A complementary perspective keeps model weights fixed and instead learns a universal perturbation. Forget vectors define a data-agnostic perturbation $A>0$3 by minimizing a forget loss on $A>0$4, a retain cross-entropy on $A>0$5, and an $A>0$6 penalty (Sun et al., 2024). The same work introduces “forget vector arithmetic,” in which class-specific vectors $A>0$7 are linearly combined to forget arbitrary subsets of classes (Sun et al., 2024). On CIFAR-10 class-wise forgetting, “Ours” achieves $A>0$8, $A>0$9, $w_{ij}(t)$00, and $w_{ij}(t)$01, while optimization takes approximately $w_{ij}(t)$02–$w_{ij}(t)$03 minutes compared with retraining at “$w_{ij}(t)$04 min” (Sun et al., 2024).

Whether a model has actually forgotten can itself be formalized as an audit problem. Liu and Tsaftaris define a scalar statistic

$w_{ij}(t)$05

where $w_{ij}(t)$06 is the two-sample Kolmogorov–Smirnov distance between a target model and a self-shadow model on the query dataset $w_{ij}(t)$07, and $w_{ij}(t)$08 is the corresponding distance between the self-shadow and a calibration shadow (Liu et al., 2020). The rule is simple: declare “forgotten” if $w_{ij}(t)$09, “not forgotten” if $w_{ij}(t)$10. On MNIST/SVHN/CIFAR-10, pure MNIST yields $w_{ij}(t)$11 and is classified as not forgotten, whereas pure SVHN yields $w_{ij}(t)$12 and is classified as forgotten; in ACDC cardiac diagnosis, $w_{ij}(t)$13T $w_{ij}(t)$14 $w_{ij}(t)$15T gives $w_{ij}(t)$16 and is classified as not forgotten (Liu et al., 2020).

Taken together, these systems show that wasure in contemporary ML spans token weighting, sensitivity suppression, gradient projection, input perturbation, and post hoc verification. The survey’s distinction between exact and approximate forgetting is therefore central rather than peripheral (Sha et al., 2024).

5. Logical and answer-set formulations of forgetting

Outside statistical learning, wasure corresponds to formal operators that eliminate symbols while preserving selected inferential behavior. In propositional logic, standard forgetting of $w_{ij}(t)$17 from a theory $w_{ij}(t)$18 is equivalent to existential quantification,

$w_{ij}(t)$19

and preserves all entailments of $w_{ij}(t)$20-formulas $w_{ij}(t)$21: $w_{ij}(t)$22 iff $w_{ij}(t)$23 (Doherty et al., 2023). The same paper introduces weak forgetting, dual to standard forgetting, and shows

$w_{ij}(t)$24

Standard forgetting aligns with strongest necessary conditions, while weak forgetting aligns with weakest sufficient conditions (Doherty et al., 2023).

The paper also gives an algorithmic perspective via quantifier elimination and Ackermann-style elimination. In the propositional case, if $w_{ij}(t)$25 is positive in $w_{ij}(t)$26, then

$w_{ij}(t)$27

with a dual form when $w_{ij}(t)$28 is negative in $w_{ij}(t)$29 (Doherty et al., 2023). The framework is extended to first-order logic, where standard and weak forgetting become $w_{ij}(t)$30 and $w_{ij}(t)$31, respectively (Doherty et al., 2023).

Illustrative examples underscore the semantic difference. For $w_{ij}(t)$32 over $w_{ij}(t)$33 and $w_{ij}(t)$34, standard forgetting gives $w_{ij}(t)$35, while weak forgetting gives $w_{ij}(t)$36 (Doherty et al., 2023). The paper interprets this as retaining the sufficient condition $w_{ij}(t)$37 when the $w_{ij}(t)$38-sensor is unavailable.

In ASP, the central reference point is strong persistence (SP). Forgetting an atom set $w_{ij}(t)$39 from a program $w_{ij}(t)$40 should preserve, under any added context $w_{ij}(t)$41 using only atoms outside $w_{ij}(t)$42, exactly the projections of the answer sets of $w_{ij}(t)$43 onto the remaining atoms (Gonçalves et al., 2017). However, SP is not always attainable. The criterion $w_{ij}(t)$44 characterizes precisely when an SP-satisfying forgetting operator exists; the existence theorem states that such an operator exists on $w_{ij}(t)$45 iff $w_{ij}(t)$46 does not hold (Gonçalves et al., 2017).

When $w_{ij}(t)$47 holds, three alternatives are analyzed. $w_{ij}(t)$48 preserves old answer sets but may introduce new ones; $w_{ij}(t)$49, based on relativized equivalence, avoids new answer sets but may lose old ones; and $w_{ij}(t)$50 preserves exactly the projected old answer sets but fails strong invariance (Gonçalves et al., 2017). The paper summarizes the trade-off succinctly: when one must forget but cannot satisfy strong persistence, one must choose between accepting new answer sets, accepting lost answer sets, or accepting loss of invariance. This makes wasure in logic a problem of preserving the right inferential invariants under symbol elimination.

6. Wasure as a WebAssembly benchmarking toolkit

In a completely different usage, Wasure is the name of a “lightweight, Python-based command-line toolkit” for systematic, reproducible, and extensible WebAssembly benchmarking (Carissimi et al., 5 Feb 2026). The motivation is the multidimensionality of Wasm performance evaluation across runtime engines, hardware architectures, application domains, source languages, benchmark suites, and runtime configurations (Carissimi et al., 5 Feb 2026).

The toolkit is organized into three phases: Preparation, Execution, and Evaluation. Preparation includes benchmark management and runtime management; execution includes the run module and the check module; evaluation includes export and plotting (Carissimi et al., 5 Feb 2026). Its stated design goals are ease of use, extensibility through simple JSON configurations, portability on Unix-like hosts, and accuracy through low-overhead timing, memory and resource tracking, timeouts, and repeatable trials (Carissimi et al., 5 Feb 2026). Supported runtimes include wasmtime, wasmer, V8, SpiderMonkey, JavaScriptCore, WAMR, WasmEdge, wasm3, Wizard, wasmi, and wazero; bundled benchmark suites include mibench, ostrich, dhrystone, polybench, libsodium, wasm-r3, wasm-features, and wasi-proposals; source languages include C/C++, Rust, AssemblyScript, Java, Scala, Kotlin, and OCaml (Carissimi et al., 5 Feb 2026).

The command-line interface uses subcommands such as wasure list benchmarks, wasure list runtimes, wasure install <runtime>, wasure run, wasure check, wasure export, and wasure plot (Carissimi et al., 5 Feb 2026). Runtime and benchmark descriptors reside under runtimes/ and benchmarks/ folders, allowing new entries to be added without changing the core code (Carissimi et al., 5 Feb 2026).

Beyond timing, Wasure integrates Wizard’s non-intrusive instrumentation to emit events for executed instructions and cycles, basic block entries and function calls, reads and writes to linear memory and global variables, integer versus floating-point operations, and indirect call instructions (Carissimi et al., 5 Feb 2026). The resulting dynamic analysis reveals strong benchmark heterogeneity: overall coverage is below $w_{ij}(t)$51 across suites, only mibench and dhrystone exceed $w_{ij}(t)$52 function coverage, in most suites less than $w_{ij}(t)$53 of instructions account for $w_{ij}(t)$54 of runtime, polybench and ostrich are floating-point heavy, mibench, dhrystone, libsodium, and wasm-r3 are integer-dominated, certain ostrich workloads show extreme indirect-call behavior, and dhrystone and libsodium exhibit more than $w_{ij}(t)$55 memory accesses (Carissimi et al., 5 Feb 2026). PCA clustering identifies wasm-r3 and libsodium as outliers in function diversity and memory intensity (Carissimi et al., 5 Feb 2026).

This use of the term does not concern forgetting in the algorithmic or logical sense. Rather, it is a proper name for benchmarking infrastructure. Its presence alongside the forgetting literature is a reminder that Wasure is lexically stable across papers while semantically diverse.

7. Conceptual unities and persistent tensions

Despite the diversity of usages, several recurrent themes are visible across the literature. First, forgetting is repeatedly framed as adaptive rather than merely defective: the survey explicitly links it to avoiding cognitive overload, adapting to changing environments, and preventing “experience over-fitting” (Sha et al., 2024). Second, the hardest technical issue is nearly always the privacy–utility or plasticity–stability tension. In associative memory, saturation prevents catastrophic interference but produces exponentially tiny basins for old memories (Marinari, 2018). In unlearning, ETW, MU-Mis, PURGE, and forget vectors each try to erase target information while preserving retained performance (Koh et al., 20 Apr 2026, Cheng et al., 2024, Jawandhia et al., 2 Jun 2026, Sun et al., 2024). In logical settings, forgetting preserves some inferential content while sacrificing others when strong persistence cannot be maintained (Doherty et al., 2023, Gonçalves et al., 2017). In agent memory governance, MW is designed for suppression and deprecation, yet remains only associational and is vulnerable to hitchhiker and task-difficulty confounds (Simsek, 13 Apr 2026).

A second recurring issue is evaluation. In machine unlearning, exact forgetting is defined relative to retraining-from-scratch ideals, but many practical methods are approximate (Sha et al., 2024). PURGE targets MIA AUROC close to $w_{ij}(t)$56, MU-Mis reports remaining-data accuracy, forget-data accuracy, and membership-inference risk, ETW emphasizes aggregated score and privacy leakage, and Liu–Tsaftaris propose a dedicated audit ratio $w_{ij}(t)$57 for deciding whether forgetting occurred (Jawandhia et al., 2 Jun 2026, Cheng et al., 2024, Koh et al., 20 Apr 2026, Liu et al., 2020). This suggests that wasure is not only an intervention problem but also a verification problem.

Finally, the literature repeatedly identifies open-endedness rather than closure. The survey calls for cross-disciplinary forgetting, forgetting verification, interpretable forgetting, hybrid forgetting, source-free forgetting, and a “Goldilocks zone of forgetting” (Sha et al., 2024). Marinari argues that hard cut-offs should be replaced by more graded or stochastic forgetting, such as palimpsest schemes and multi-timescale plasticity, to avoid exponentially collapsing retrieval basins while preserving capacity of order $w_{ij}(t)$58 (Marinari, 2018). The cumulative picture is that Wasure marks an active research area in which erasure, suppression, abstraction, and governance are technically unified by a single question: how should past information stop mattering without destroying the computational system that once relied on it?