Erasure Transformation: Theory & Applications

• Erasure transformation is a method that converts latent or unwanted states into explicit forms—such as flagged errors, reset states, or merged representations—to facilitate detection and control.
• It enhances fault-tolerant quantum computing by converting hidden physical faults into known erasures, thereby increasing decoder effectiveness and error thresholds.
• In coding, thermodynamics, and machine learning, the approach enables precise operations like recursive transforms, state resets, and concept removal, yielding measurable performance gains.

Searching arXiv for the provided topic and core papers to ground the article. Across recent literature, erasure transformation denotes a family of operations that re-express unwanted states, errors, concepts, or terms in a form that is easier to detect, reset, decode around, or compile away. In fault-tolerant quantum computing, it typically means converting hidden physical faults into erasures—errors at known locations—so that decoders can exploit location information (Wu et al., 2022). In thermodynamics and constructor theory, it denotes the physically implemented map from an arbitrary memory state to a fixed reference state, usually a pure state, together with the question of whether such a task is cyclically realizable (Violaris et al., 2022). In coding theory, it refers to recursive transforms of erasure-structured channels and sources under polarization (Sakai et al., 2016). In generative modeling, federated unlearning, and type theory, it denotes structured transformations of activations, parameters, representations, or phases that remove target content while preserving other behavior (Chen et al., 6 Aug 2025).

1. Core meanings and formal scope

The term is therefore best understood as domain-specific but structurally recurrent. In each setting, the transformation operates on a different object—noise channels, memory states, channel laws, network representations, or typed terms—but the common aim is to move from an inconvenient or latent form of information to a form that is explicitly flagged, absorbed into a reference class, or made runtime-irrelevant.

Domain	Object transformed	Operational meaning
Fault-tolerant quantum computing	Physical errors or leakage	Conversion to detected erasures
Thermodynamics / constructor theory	Memory states	Mixed-to-pure reset task
Polar coding / source polarization	Erasure-structured channels or sources	Recursive minus/plus transform
Generative models / unlearning	Features, activations, or parameters	Removal of target concepts
Type theory	Terms and contexts	Phase-directed compilation erasure

A useful distinction runs through these uses. In some papers, erasure transformation is a physical-channel reshaping: the underlying hardware is engineered so that dominant faults leave the computational subspace and become detectable (Wu et al., 2022). In others, it is a state-reset map such as $\rho \mapsto |\phi\rangle\langle\phi|$ (Violaris et al., 2022). Elsewhere, it is an algebraic transform on probability vectors or subgroup-indexed erasure distributions (Sakai et al., 2016), or a representation transform that merges a target class or concept into a benign one (Guo et al., 2024).

This breadth matters because the same word, erasure, can mean at least four distinct things: known-location faults, logical reset, partial information loss in a channel, and deliberate removal of model capabilities. Treating them as interchangeable obscures the technical structure of each literature.

2. Fault-tolerant quantum computing: from hidden faults to known-location erasures

In quantum error correction, the central distinction is between generic Pauli noise and erasure errors, for which the decoder knows the affected locations. The canonical one-qubit quantum erasure channel is

$$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$

with $|e\rangle$ orthogonal to the computational subspace. Because the erased set is known, a distance-$d$ stabilizer code can correct up to $d-1$ erasures, whereas generic Pauli noise is limited by the usual $\lfloor(d-1)/2\rfloor$ mechanism. The guiding idea of erasure transformation is therefore not necessarily to reduce the raw physical error rate, but to increase the information available to the decoder about where errors occurred (Wu et al., 2022).

A detailed realization was proposed for ${}^{171}\mathrm{Yb}$ Rydberg arrays by encoding the qubit in the metastable $6s6p\,{}^3P_0$ manifold and arranging two-qubit blockade gates so that dominant Rydberg-decay channels leave the qubit subspace and enter disjoint manifolds that can be monitored by fluorescence (Wu et al., 2022). The paper defines an effective erasure fraction

$R_e \equiv \frac{p_e}{p_e+p_p}\approx 0.98,$

meaning that 98% of spontaneous-decay-induced errors are converted into erasures. In circuit-level simulations of the planar XZZX surface code, this raised the threshold from $0.937(4)\%$ for pure Pauli noise to $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$0 for mixed Pauli+erasure noise with $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$1, while the pure-erasure limit reached approximately $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$2 (Wu et al., 2022). For a distance-$$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$3 code, the fitted logical-error exponent increased from $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$4 at $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$5 to $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$6 at $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$7, approaching the pure-erasure value $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$8.

Experimental implementations followed. In a high-fidelity Rydberg quantum simulator, fast imaging of alkaline-earth atoms was used to realize erasure conversion while leaving atoms in a metastable state unperturbed. After excising runs with observed erasures, the lower bound for Bell-state generation fidelity was reported as $$\mathcal{E}(\rho)=(1-p_e)\rho + p_e |e\rangle\!\langle e|,$$9, improving to $|e\rangle$0 after correcting for remaining state-preparation errors (Scholl et al., 2023). In molecular tweezer arrays, site-resolved detection of internal-state errors and mid-circuit conversion of blackbody-induced errors into detectable erasures were demonstrated, with a composite detection scheme designed to minimally affect error-free qubits (Holland et al., 2024). These experiments establish that erasure transformation is not limited to abstract decoder models; it can be implemented through spectroscopy, shelving, fluorescence, and mid-circuit state discrimination.

Recent superconducting work pushes the same logic into bosonic encodings. For dual-rail erasure qubits defined by the one-photon subspace of two coupled cavities, dynamical control schemes were proposed that suppress erasure-check errors by two orders of magnitude and reduce logical two-qubit gate infidelities by up to three orders of magnitude, explicitly reshaping transmon-induced noise toward detectable leakage rather than undetected logical faults (Dakis et al., 9 Oct 2025). Complementary architectural work on neutral-atom surface codes addresses a distinct problem: even when leakage is converted into erasure, erasures accumulate. The proposed $|e\rangle$1-shift erasure recovery scheme uses code deformation to transfer logical information from an imperfect array with accumulated erased qubits to a perfect array, while offline erasure repair proceeds in the evacuated region (Kobayashi et al., 2024). A plausible implication is that erasure transformation at the hardware level and erasure-tolerant logical motion at the code level are increasingly being treated as a single stack.

3. Thermodynamic and constructor-theoretic erasure

In thermodynamics, erasure transformation is the logically irreversible reset of a memory to a standard state. For a qubit memory, the idealized map is

$|e\rangle$2

for every input state $|e\rangle$3, or more generally $|e\rangle$4 in the quantum Szilard-engine setting (Violaris et al., 2022). This is the standard setting of Landauer’s principle, where erasing one bit at temperature $|e\rangle$5 requires at least $|e\rangle$6 of heat dissipation, or more generally $|e\rangle$7.

The constructor-theoretic analysis of erasure by a quantum homogenizer adds a different notion of cost (Violaris et al., 2022). The homogenizer consists of a system qubit interacting sequentially with $|e\rangle$8 reservoir qubits through a partial swap

$|e\rangle$9

with $d$0 and $d$1. Single-shot homogenization can approximately realize $d$2 while leaving the reservoir approximately unchanged. The paper then asks whether this can define a constructor in the strict sense: a machine that performs the task to arbitrarily high accuracy while retaining the ability to do so again indefinitely. Using the relative-deterioration quantity

$d$3

with $d$4 the output error and $d$5 the reservoir robustness after $d$6 uses, the paper shows a sharp asymmetry. In the weak-coupling limit, the pure-to-mixed task satisfies $d$7, but the mixed-to-pure task satisfies $d$8 (Violaris et al., 2022). The interpretation is that single-shot erasure is possible, but no cyclic, arbitrarily accurate homogenizer-constructor exists for mixed-to-pure erasure in that model.

A finite-reservoir analogue appears in spin-based Landauer schemes. Memory erasure can be implemented using a reservoir of energy-degenerate spin-$d$9 particles under conservation of spin angular momentum rather than energy, with cost measured in dissipation of $d-1$0 (Croucher et al., 2021). The inverse spin temperature is

$d-1$1

and the infinite-reservoir spin-based Landauer bound takes the form

$d-1$2

For finite reservoirs, the erasure cost statistics deviate from the infinite case, the amount of erased information is reduced, ancillary-spin reset contributes an additional cost, and repeated reuse degrades performance (Croucher et al., 2021). The paper quantifies closeness between finite and infinite reservoirs using the Jensen–Shannon Divergence, emphasizing that the physically relevant question is not only average cost but the full distribution of erasure costs.

These results make a recurring point. In fault-tolerant quantum computing, erasure transformation adds location information to faults. In thermodynamics, by contrast, erasure transformation removes logical information from a memory. The two uses share the term erasure but invert the direction of information flow.

4. Polarization, generalized erasure channels, and source transforms

In coding theory, erasure transformation appears as an exact recursive update of erasure-structured channels and sources under Arıkan-style polarization. For the $d-1$3-ary input generalized erasure channel

$d-1$4

the output reveals a residue class modulo a divisor $d-1$5 of $d-1$6: $d-1$7 gives exact input recovery, $d-1$8 gives complete erasure, and intermediate divisors yield partial information (Sakai et al., 2016). Under the one-step polar transform parameterized by $d-1$9, the synthesized channels are equivalent to channels of the same family with updated parameters

$\lfloor(d-1)/2\rfloor$0

The minus branch therefore aggregates via $\lfloor(d-1)/2\rfloor$1, pushing mass toward more erased levels, while the plus branch aggregates via $\lfloor(d-1)/2\rfloor$2, pushing mass toward less erased levels (Sakai et al., 2016). When $\lfloor(d-1)/2\rfloor$3, this reduces exactly to the binary erasure channel recursion $\lfloor(d-1)/2\rfloor$4 and $\lfloor(d-1)/2\rfloor$5.

The same logic extends to non-stationary memoryless sources over possibly infinite alphabets. For a Polish group $\lfloor(d-1)/2\rfloor$6, the source side information is defined by cosets of finite normal subgroups, so that $\lfloor(d-1)/2\rfloor$7 is uniform over a coset and

$\lfloor(d-1)/2\rfloor$8

The Arıkan-style source transform

$\lfloor(d-1)/2\rfloor$9

induces a subgroup-lattice recursion in which minus branches combine subgroup types by product and plus branches by intersection (Sakai et al., 2019). When ${}^{171}\mathrm{Yb}$0 is locally cyclic, this yields multilevel source polarization with countably infinite levels, and the asymptotic entropy levels are ${}^{171}\mathrm{Yb}$1 for finite normal subgroups ${}^{171}\mathrm{Yb}$2 (Sakai et al., 2019). This is a genuine erasure transformation in the sense that the source’s uncertainty is iteratively re-expressed as uniformity over progressively refined or coarsened subgroup cosets.

A conceptually related but implementation-focused use appears in software MDS codes. Polynomial ring transforms map computations for erasure coding from the field ${}^{171}\mathrm{Yb}$3 into the ring

${}^{171}\mathrm{Yb}$4

where multiplication reduces to cyclic shifts and XORs (Detchart et al., 2017). The field-to-ring mappings ${}^{171}\mathrm{Yb}$5, ${}^{171}\mathrm{Yb}$6, ${}^{171}\mathrm{Yb}$7, and ${}^{171}\mathrm{Yb}$8 preserve the field-level semantics while lowering the cost of multiplication, especially when sparse ring representations are used. The paper explicitly interprets this as a transformation of erasure-coding computations rather than of the code definition itself: heavy operations are moved into a domain in which they are cheaper, while the MDS behavior remains unchanged.

5. Machine learning: concept erasure and representation transformation

In contemporary generative modeling, erasure transformation usually means removing a target concept from a pretrained model while preserving non-target behavior. One line of work treats this as a closed-form parameter transformation. In text-to-image diffusion models, "ErasePro" formulates concept erasure as a constrained alignment problem with a strict zero-residual condition

${}^{171}\mathrm{Yb}$9

and solves

$6s6p\,{}^3P_0$0

thereby enforcing exact target-to-anchor alignment on the training subspace (Chen et al., 6 Aug 2025). The method then applies this progressively from shallow text layers to deeper cross-attention layers, so that later layers require smaller parameter deviations and overall generative quality is better preserved. On the reported benchmarks, ErasePro achieved complete erasure for the target concepts in its CLIP-accuracy evaluations, including explicit nudity erasure, while also preserving anchor and unrelated concepts more effectively than prior closed-form baselines (Chen et al., 6 Aug 2025).

A second line treats erasure transformation as a constrained optimization problem in flow-based transformers. "EraseAnything++" formulates concept erasure in image and video rectified-flow models as multi-objective optimization over an erasure loss $6s6p\,{}^3P_0$1 and a preservation loss $6s6p\,{}^3P_0$2, with an update direction chosen under an explicit preservation constraint and implemented efficiently by implicit gradient surgery (Fan et al., 1 Mar 2026). The transformation is parameterized with LoRA updates on attention projections and attention-level regularization; in video, an anchor-and-propagate mechanism enforces temporal consistency. This suggests a broadened meaning of erasure transformation: not merely removing a concept from a static text-to-image map, but modifying an entire conditional flow field while constraining collateral damage.

A third line avoids parameter updates entirely. "ActErase" defines a training-free transformation on FFN activations. For each layer $6s6p\,{}^3P_0$3, it computes source and target importance scores

$6s6p\,{}^3P_0$4

constructs a binary mask

$6s6p\,{}^3P_0$5

and patches activations during the forward pass via

$6s6p\,{}^3P_0$6

The result is a deterministic activation-space erasure transformation that leaves weights unchanged while suppressing target concepts at inference time (Sun et al., 1 Jan 2026).

Outside generative models, the same structural motif appears in federated unlearning. FUCRT performs class-aware representation transformation by relabeling samples from unlearning classes to selected transformation classes and then applying cross-entropy together with local and global class-aware contrastive losses (Guo et al., 2024). The reported outcome is complete $6s6p\,{}^3P_0$7 erasure of unlearning classes while maintaining or improving performance on remaining classes across IID and Non-IID settings (Guo et al., 2024). Here, erasure transformation does not delete parameters or examples; it geometrically merges one representation cluster into another so that the forgotten class no longer occupies a separable region.

6. Type theory with erasure: phase distinction and compilation

In type theory, erasure transformation is neither noise conversion nor concept suppression. It is the mathematically justified removal of runtime-irrelevant terms during compilation. "Type Theory With Erasure" formalizes this as a phase distinction between runtime-relevant terms of mode $6s6p\,{}^3P_0$8 and erased terms of mode $6s6p\,{}^3P_0$9, together with an erasure marker $R_e \equiv \frac{p_e}{p_e+p_p}\approx 0.98,$0 that can appear in contexts (Theocharis et al., 1 May 2026). The core structural isomorphism is

$R_e \equiv \frac{p_e}{p_e+p_p}\approx 0.98,$1

so that in an erased context, runtime and erased terms can be interconverted. Universes are themselves placed in the erased phase, and the system is formulated as a second-order generalized algebraic theory.

Semantically, the erased phase is modeled using a tiny proposition in families of sets and, more generally, in any Grothendieck topos equipped with such a proposition (Theocharis et al., 1 May 2026). For code extraction, the authors construct a presheaf model into the untyped lambda calculus. In the extraction model, erased terms are sent to terminal objects while runtime terms are interpreted as untyped lambda terms; contexts extended by erased variables are semantically unchanged, whereas contexts extended by runtime variables add free variables. The paper proves correctness through gluing and establishes conservativity over Martin-Löf type theory in both runtime and erased phases (Theocharis et al., 1 May 2026).

The phrase erasure transformation therefore acquires yet another precise meaning: a compilation map from a dependently typed source language to a runtime core, justified not by heuristic dead-code elimination but by a semantic theorem that erased components are phase-irrelevant.

7. Common structure, recurring misconceptions, and open distinctions

A persistent misconception is that erasure transformation always means deletion. The surveyed literature shows a more nuanced pattern. In quantum fault tolerance, erasure transformation often means making errors loud rather than small: dominant faults are pushed into monitored subspaces, and the gain comes from decoder side information, not necessarily from a lower raw fault rate (Wu et al., 2022). In constructor theory, by contrast, erasure is explicitly the mixed-to-pure reset map, and the central issue is whether the resetting device can function cyclically (Violaris et al., 2022). In polarization, erasure transformation is an exact recursion on residue-class or subgroup-indexed uncertainty (Sakai et al., 2016). In generative modeling and unlearning, it is a structured reassignment of internal representations or conditional trajectories rather than literal deletion of parameters (Chen et al., 6 Aug 2025).

Another misconception is that Landauer’s bound exhausts the cost of erasure. The constructor-theoretic homogenizer analysis argues for an additional irreversibility notion: entropy bookkeeping may be symmetric while constructor possibility is not, because mixed-to-pure erasure can fail to admit a cyclic, arbitrarily accurate constructor even when the reverse task does (Violaris et al., 2022). A plausible implication is that “cost” in erasure transformations should be indexed to the formal framework—heat, spin angular momentum, decoder overhead, activation drift, or compilation correctness—rather than treated as a single scalar.

Across these domains, the common structure is not a single equation but a shared design principle. A latent, inconvenient, or high-overhead object is transformed into one of four more tractable forms: a flagged error, a reference state, an algebraically closed channel family, or a runtime-irrelevant artifact. The technical differences are substantial, but the family resemblance is strong: erasure transformation is repeatedly used to trade raw expressive freedom for controllable structure.