EvE Code: Verification & Editing Framework

• EvE Code is a collection of specialized computational frameworks that address machine unlearning verification, zero-shot video editing with depth guidance, and ENSDF editing for nuclear data.
• Each system employs domain-specific innovations like bilevel optimization, latent diffusion with geometric constraints, and record-based parsing for robust, verifiable results.
• The frameworks demonstrate significant efficiency gains, with near-perfect verification rates, rapid video editing speeds, and enhanced usability for nuclear data evaluation.

EvE Code encompasses a collection of distinct computational frameworks and software packages developed for use in machine learning verification, text-based video editing, and nuclear data evaluation. The three best-documented EvE systems in the academic literature are: (1) EVE for efficient zero-shot text-based video editing with depth and temporal constraints (Chen et al., 2023); (2) EVE for efficient verification of data erasure in approximate unlearning (Wang et al., 3 Feb 2026); and (3) EVE, a context-dependent editor for nuclear data evaluators (Shulyak et al., 2010). Each codebase addresses domain-specific challenges using algorithmic and engineering innovations, but they share a strong emphasis on efficiency, extensibility, and verifiability.

1. EVE for Efficient Verification of Data Erasure (Machine Unlearning) (Wang et al., 3 Feb 2026)

EVE provides a framework for verifying whether a model's approximate unlearning mechanism, executed in response to a user data erasure request, has been genuinely and correctly performed—without requiring any participation in initial training or backdoor instrumentation. The method is designed for settings where users have black-box access to a pre-trained model $f_{\theta^*}$ and request the erasure of a selected dataset $D_u$.

The process involves the user perturbing each data point in $D_u$ with a small, customized perturbation $\delta_i$, constructing a perturbed set $D_u^p$. This perturbation is chosen such that if the server's unlearning is properly conducted, a small verification set $\mathcal{V}$ will exhibit flipping of prediction labels under the unlearned model $f_{\theta_u}$. The perturbations are computed by minimizing the cosine distance between the aggregate unlearning gradient over $D_u^p$ and a “signal” gradient derived from the verification set, all under tight norm constraints.

Key equations include the bilevel optimization for perturbation generation: $$\min_{\delta}\;\sum_{t=1}^T \mathcal{L}_u\big((x_t, y \neq y_t);\theta_u\big)\ \ \text{s.t.}\ \ \theta_u \in \arg\min_{\theta} \sum_{i=1}^M \mathcal{L}_u\big((x_i+\delta_i, y_i);\theta\big), \ \ \|\delta_i\|_\infty \leq d.$$ This is reduced to a single-level gradient-matching objective by cosine similarity minimization: $$\phi(\delta;\theta^*) = 1 - \frac{\langle g_{\text{sig}}, g_{\text{unlearn}} \rangle}{\|g_{\text{sig}}\|\,\|g_{\text{unlearn}}\|},$$ where $g_{\text{sig}}$ is the verification set loss-gradient and $g_{\text{unlearn}}$ is the perturbed unlearning data gradient. Perturbations are updated via projected gradient descent to maintain the desired norm bound.

Statistical verification follows the unlearning by assessment of error rate $\hat{\alpha}$ on the verification set, with a hypothesis test comparing to random-chance $\beta$.

A summary of project structure and usage, as implemented in the released repository, is:

Component	Description	Location
UDPD implementation	Perturbation generation (Algorithm 1)	scripts/generate_perturb.py
Unlearning pipeline	Applies unlearning algorithms to the perturbed set	scripts/run_unlearn.py
Verification script	Executes the hypothesis test (Theorem 1)	scripts/verify_unlearn.py

EVE exhibits orders-of-magnitude speedups over backdoor- or retraining-based verification methods, with verifiability remaining near 100% across standard datasets and minimal model utility degradation (Wang et al., 3 Feb 2026).

2. EVE for Zero-Shot Text-Based Video Editing with Depth Guidance (Chen et al., 2023)

EVE in video editing is a robust, zero-shot text-driven video editing pipeline achieving high temporal consistency and data fidelity by explicitly guiding the diffusion process with depth maps and temporal constraints. The system leverages latent diffusion models (LDMs) for video frame denoising, integrates MiDaS-generated depth features to control geometric structure, and enforces optical-flow-based temporal consistency.

Editing is executed by optimizing the noise sequence during DDIM denoising, subject to a composite loss: $$L = \alpha L_{\text{diffusion}} + \beta L_{\text{text}} + \gamma L_{\text{depth}} + \delta L_{\text{temp}},$$ where

• $L_{\text{diffusion}}$: Standard denoising loss,
• $L_{\text{text}}$: CLIP-guided text matching,
• $L_{\text{depth}}$: L1 depth feature consistency, $$L_{\text{depth}} = \| D_{\text{orig}} - D_{\text{edited}} \|_1$$,
• $L_{\text{temp}}$: Temporal frame alignment, $$L_{\text{temp}} = \sum_{t=1}^{K-1} \| \bar{I}_{t+1}^e - W(\bar{I}_t^e) \|_2^2$$.

The editing process operates in zero-shot mode, requiring no model fine-tuning, and is applicable to arbitrary mp4/avi videos by sampling a sequence of frames. Depth guidance is handled by MiDaS; if precomputed maps are unavailable, they are generated on the fly. The system's hyperparameters, such as DDIM steps and loss term weights (e.g., $\lambda_{\text{temp}}$, $\lambda_{\text{depth}}$), can be tuned to balance creative variability against geometric and temporal stability.

Performance benchmarks on the ZVE-50 dataset demonstrate state-of-the-art trade-offs in temporal consistency and edit relevance at substantially lower computational cost compared to tuning-heavy methods. For an 8-frame video, EVE completes editing in approximately 83 seconds on an A40 GPU, compared to 247.6 seconds for FateZero and 30 minutes for Tune-A-Video.

The codebase is modular, organized with distinct submodules for LDM, depth extraction, frame alignment, and evaluation scripts. The released ZVE-50 benchmark allows reproducible and standardized assessment of editing performance (Chen et al., 2023).

3. EVE Evaluator’s Editor for ENSDF Files (Shulyak et al., 2010)

EVE in the context of nuclear physics denotes an extensible C-based editor specialized for the Evaluated Nuclear Structure Data File (ENSDF) format. It provides both text-mode (ncurses) and GUI (GTK+/Gnome) front-ends and is architected to maximize editing efficiency while ensuring syntactic and semantic validation.

Key architectural modules include a configuration manager for field/record definitions, a parser/validator with POSIX-regular-expression checking, an edit engine supporting context-dependent navigation and undo, and a UI manager providing color-coded field display and error highlighting. The EVE data model operates as a sequence of ENSDF records, each with fixed-width buffers and field-level error and modification flags.

Editing workflow is governed by strict field-centric cursor motion, automatic context-sensitive case normalization, record-type awareness (e.g., NUCID inheritance), immediate error highlighting, and a comprehensive command suite covering navigation, marking/copying blocks, and robust integration with an external nuclear level-scheme viewer.

All configuration files (ENSDF.def, COLORS.def, .eve.rc) support user and system-level overrides for full schema, color, and attribute customization. The external viewer enables live visualization of nuclear level diagrams and is invoked from EVE through hot-keys or GUI commands, streamlining dataset verification and exploration. EVE does not process LaTeX, displaying all quantities as in raw ENSDF—indices are only visually offset in the viewer (Shulyak et al., 2010).

4. Algorithmic Methodologies and Core Formulations

The various EVE codebases are unified by their reliance on domain-specific algorithmic formulations:

• EVE unlearning verification: Bilevel adversarial perturbation optimization, gradient-matching under norm constraint, and post-unlearning hypothesis testing.
• EVE video editing: Latent diffusion optimization constrained by depth-map L1 losses and optical-flow-based temporal penalties, with CLIP-based text alignment as an additional regularizer.
• EVE ENSDF: Record-oriented parsing, real-time regular-expression-based validation, and interactive, context-sensitive field manipulation.

For machine unlearning, Algorithm 1 (UDPD) implements projected gradient descent on $\delta_i$ to minimize cosine dissimilarity. In video editing, the DDIM-based denoising routine optimizes over latent variables, combining denoising, textual, geometric, and temporal losses within each step.

5. Installation, Usage, and Reproducibility

Each EVE release provides a carefully structured repository enabling efficient setup, extensibility, and experiment reproducibility:

System	Language/Stack	Main Dependencies	Installation Method
EVE unlearning verification	Python 3.8–3.9, PyTorch	torch, numpy, scipy, torchvision	pip install -r requirements.txt
EVE video editing	Python 3.8–3.9, PyTorch	diffusers, transformers, einops, timm	pip install -r requirements.txt + pretrained DL
EVE ENSDF editor	C, Unix/Linux	ncurses, GTK+/Gnome, POSIX utils	Makefile/compilation under POSIX/Unix environments

Reproducibility is a core design criterion, with benchmark datasets (e.g., ZVE-50, standard ML datasets) and scripting support for end-to-end workflows.

6. Applications, Impact, and Performance Benchmarks

EVE for machine unlearning achieves perfect verification rates across datasets such as MNIST, CIFAR-10, and CelebA with minimal loss in model accuracy and dramatically reduced runtime compared to prior approaches. EVE video editing enables high-fidelity, temporally consistent, and efficient text-based video editing in a zero-shot regime, filling a gap between heavily tuned and uncreatively constrained generations. EVE for ENSDF streamlines evaluation, editing, and validation of complex nuclear datasets in both research and educational environments, supporting integration with visualization systems for rapid knowledge extraction.

Notable performance results include:

Benchmark	EVE unlearning (CIFAR-10)	EVE video editing (ZVE-50)
Verification rate	$\hat\alpha \approx 1.0$	N/A
Editing time/video	N/A	83.1 s (8 frames, A40 GPU)
Utility drop	$<0.7\%$ accuracy	N/A

A plausible implication is that EVE's lightweight, domain-adaptive control frameworks represent an emerging paradigm for efficient, user-centric, and verifiable editing and verification across both generative and data management workflows.