Reboot in Research: Recovery Under Constraints

• Reboot is a term for structured recovery methods that restart processes by preserving key internal structures under constrained information.
• It spans applications from residual-based bandit exploration and replay-buffer bootstrapping in robotics to time reconstruction in sensor networks and secure software translation.
• Each approach employs domain-specific strategies—such as forcing variance in bandits or reusing past trajectories in RL—to achieve practical improvements in performance and reliability.

“Reboot” denotes several distinct research constructs rather than a single technical method. In the cited literature, the term appears as residual bootstrap exploration for stochastic bandits, replay-buffer bootstrapping for real-world dexterous manipulation, robustness to literal mote reboots in time reconstruction, a mostly-automatic workflow for translating C interpreters into safe Rust, and fully encrypted deep neural network training with CKKS bootstrapping (Wang et al., 2020, Hu et al., 2023, Gupchup et al., 2019, Wang et al., 25 Jun 2026, Pirillo et al., 24 Jun 2025). The common lexical motif is reinitialization under constrained information: uncertainty is re-sampled from residuals, prior experience is reused to start a new task, clock state is reconstructed after device resets, translation proceeds through reduced milestones, and ciphertext modulus space is refreshed during encrypted optimization. This suggests that “reboot” functions as a recurring label for methods that recover or restart computation while preserving useful structure.

1. Residual bootstrap exploration in bandit algorithms

In stochastic bandits, ReBoot is a perturbation-based exploration method that injects data-driven randomness through a residual-based mechanism rather than relying on a pre-specified optimism bonus or a posterior sample (Wang et al., 2020). In the stochastic $K$-armed setting over $T$ rounds, the learner chooses an arm $I_t\in\{1,\dots,K\}$, observes reward $r_t\sim P_{I_t}$, defines the optimal arm so that $\mu_1=\mu_*\ge \mu_k$ for $k>1$, and measures regret by

$$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$

For an arm pulled $s$ times, ReBoot forms residuals

$\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$

then appends two pseudo-residuals

$$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$

With i.i.d. bootstrap weights $T$0 satisfying $T$1 and $T$2, the perturbed index is

$T$3

and the algorithm plays the arm with maximal $T$4 (Wang et al., 2020).

The distinctive feature is variance inflation through pseudo-residuals. The method sets $T$5 with $T$6 and, in practice, $T$7–$T$8, so that the pseudo-residual sum of squares

$T$9

dominates under-exploration when $I_t\in\{1,\dots,K\}$0 is small and vanishes relatively as $I_t\in\{1,\dots,K\}$1 (Wang et al., 2020). For Gaussian bandits $I_t\in\{1,\dots,K\}$2 and $I_t\in\{1,\dots,K\}$3, ReBoot satisfies an instance-dependent logarithmic regret bound,

$I_t\in\{1,\dots,K\}$4

with

$I_t\in\{1,\dots,K\}$5

and in particular, taking $I_t\in\{1,\dots,K\}$6 and assuming $I_t\in\{1,\dots,K\}$7 gives

$I_t\in\{1,\dots,K\}$8

The linear-bandit extension, LinReBoot, replaces armwise empirical means by ridge regression and perturbs the fitted linear reward with resampled residuals (Wu et al., 2022). The reward model is

$I_t\in\{1,\dots,K\}$9

with conditionally sub-Gaussian noise. After $r_t\sim P_{I_t}$0 rounds,

$r_t\sim P_{I_t}$1

For each arm $r_t\sim P_{I_t}$2 with $r_t\sim P_{I_t}$3 past pulls and residuals

$r_t\sim P_{I_t}$4

the algorithm draws i.i.d. Gaussian bootstrap weights $r_t\sim P_{I_t}$5 and forms

$r_t\sim P_{I_t}$6

Conditionally,

$r_t\sim P_{I_t}$7

where $r_t\sim P_{I_t}$8 (Wu et al., 2022).

Under bounded $r_t\sim P_{I_t}$9, bounded contexts, sub-Gaussian noise, and a mild ridge-validity assumption that the early design matrix has full rank with a gap $\mu_1=\mu_*\ge \mu_k$0, LinReBoot achieves a high-probability $\mu_1=\mu_*\ge \mu_k$1 regret bound (Wu et al., 2022). The proof combines a self-normalized martingale bound for $\mu_1=\mu_*\ge \mu_k$2, a tail bound for the bootstrap perturbation, an anti-concentration event for the optimal arm, and an elliptical-potential argument. Section 4 of the paper decomposes the optimistic-estimate discrepancy as

$\mu_1=\mu_*\ge \mu_k$3

where $\mu_1=\mu_*\ge \mu_k$4 is “sample optimism” and $\mu_1=\mu_*\ge \mu_k$5 is “bootstrap optimism.” The reported interpretation is that the strength of bootstrap exploration is based on collaborated optimism between the online-learned model and the re-sampling distribution of residuals (Wu et al., 2022).

A common misconception is that ReBoot is simply Thompson sampling with a different random seed. The bandit papers do not make that identification. Instead, they define exploration through residual perturbations derived from fitting errors, with explicit residual or pseudo-residual constructions and regret analyses that differ from posterior sampling formulations (Wang et al., 2020, Wu et al., 2022).

2. Replay-buffer bootstrapping for real-world dexterous manipulation

In dexterous manipulation, REBOOT stands for “REuse data for BOOTstrapping Efficient Real-World Dexterous Manipulation” and addresses sample inefficiency, environment resets, and reward engineering in contact-rich real-world RL (Hu et al., 2023). The setting is in-hand reorientation and posing of underactuated, rigid objects using a multi-fingered 16-DoF robot hand, where the hand must establish and break contacts, maintain non-prehensile forces, and coordinate 16 joint actuators.

The system combines four ingredients: a sample-efficient off-policy RL core, specifically RLPD as a variant of SAC; replay-buffer bootstrapping from prior tasks; learned resets via imitation; and learned classifier-based reward functions using VICE (Hu et al., 2023). The algorithm pre-loads a prior replay buffer $\mu_1=\mu_*\ge \mu_k$6 with trajectories from previously learned tasks or objects, collects a demonstration dataset $\mu_1=\mu_*\ge \mu_k$7 for picking up the object, learns a reset policy $\mu_1=\mu_*\ge \mu_k$8 by minimizing

$\mu_1=\mu_*\ge \mu_k$9

and then trains a fresh RLPD agent by sampling mixed mini-batches of transitions, 50% from $k>1$0 and 50% from $k>1$1 (Hu et al., 2023). The RL objective remains

$k>1$2

Replay-buffer bootstrapping is deliberately simple. To learn task $k>1$3, the method initializes the replay buffer with transitions from completed tasks $k>1$4 and uses uniform 50/50 mixing without importance-sampling corrections, relying on RLPD’s stability under mixed data (Hu et al., 2023). The stated intuition is that prior data provides examples of rich finger-object contacts and dynamics, so the Q-function and policy learn useful embedding features that accelerate learning on new but related tasks. Empirically, REBOOT achieves up to a $k>1$5 reduction in wall-clock time to reach target success rates (Hu et al., 2023).

The learned reset mechanism addresses the operational bottleneck that every failed in-hand rollout can require object pickup from arbitrary table poses. Demonstrations are collected via tele-operation with a 3-D mouse at approximately 30 s per demo. In practice, two behavioral cloning policies are trained, a multi-object policy and a single-object policy, and each episode start stochastically chooses between them, for example 80% versus 20%, to avoid getting stuck in failure states (Hu et al., 2023). Reported reset success rates are approximately 60% for the 3-prong object, 66% for the T-pipe, and 37% for the football, and these are described as sufficient to keep overall training autonomous.

Reward specification is delegated to a VICE discriminator. For each task $k>1$6, the user provides goal images $k>1$7 depicting the desired final in-hand pose. The discriminator $k>1$8 is trained with

$k>1$9

with labels $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$0 for goal images, $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$1 for $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$2, and frozen reward labels for offline data in $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$3 (Hu et al., 2023). The instantaneous reward used for RL is

$$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$4

The experimental program uses three objects—the purple 3-pronged valve, black T-shaped pipe, and blue toy football—and tasks consisting of in-hand reorientation into specific target poses (Hu et al., 2023). The reported gains are concrete: for 3-Prong Pose B, REBOOT reaches 80% success in approximately 6 h versus approximately 13 h from scratch; for T-Pipe, 60% success in 6 h versus 13 h from scratch; and for Football, 30% in 5 h versus 16 h from scratch. Ablations show that 60 k initialization transitions outperform 30 k, both outperform no initialization; initializing from the same object helps most, though other-object data still helps; and simple policy finetuning yields smaller gains than replay initialization (Hu et al., 2023). In Mujoco simulation with 500 k steps, REBOOT remains stable and outperforms the no-init baseline.

A plausible implication is that “reboot” here denotes not a reset of the robot system but a restart of learning from prior interaction data. The paper nevertheless emphasizes limits: it was tested on 3–4 skills, the effect of hundreds of prior tasks is unclear, the task scope is only in-hand reorientation of rigid objects, reset success varies substantially by object shape, and no tactile sensing is used (Hu et al., 2023).

3. Reboots as failures and reconstruction events in sensor networks

In wireless sensing, reboot has its literal systems meaning: motes often reboot and lose their clock state, especially because the majority of mote platforms lack a real-time clock (Gupchup et al., 2019). The paper “Phoenix: An Epidemic Approach to Time Reconstruction” does not name its algorithm “Reboot,” but device reboots are the central failure mode that motivates the method (Gupchup et al., 2019). Phoenix is an offline algorithm for reconstructing global timestamps that is robust to frequent mote reboots and does not require a persistent global time source.

For a single continuous run between reboots, called a “segment,” Phoenix models the relationship between a mote’s local timestamp $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$5 and true global time $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$6 by the affine map

$$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$7

Here $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$8 is clock skew and $$R(T)=E\Big[\sum_{t=1}^T (\mu_*-\mu_{I_t})\Big] =\sum_{k=2}^K \Delta_k\,E[T_{k,T}]\,.$$9 is the global time at which the segment’s local clock reads zero. Whenever the mote reboots, $s$0 jumps back to zero and a new $s$1 must be re-estimated (Gupchup et al., 2019).

Phoenix reconstructs time by exchanging temporal state among neighbors. Each mote in segment $s$2, identified by $s$3, beacons every $s$4 seconds:

$s$5

A neighboring mote in segment $s$6 records the 6-tuple

$s$7

Offline, Phoenix collects neighbor-to-neighbor anchors and fits

$s$8

for each pair of segments $s$9, recording $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$0 as a local fit (Gupchup et al., 2019).

Global time is propagated epidemically. A small set of segments $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$1 carries direct local-to-global anchors, for example from GPS or NTP references, and Phoenix treats the directed graph of segments as vertices with edges weighted by $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$2 from the local fits (Gupchup et al., 2019). Candidate global fits are composed transitively by formulas such as

$\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$3

or, in the inverse direction,

$\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$4

with composite goodness-of-fit

$\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$5

At termination, every segment that found a path to some global-time reference has a best-so-far $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$6, and applying $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$7 yields timestamps for recorded samples (Gupchup et al., 2019).

The reboot-handling procedure is explicit. On reboot of mote $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$8, the reboot count is incremented, a new segment starts with $\epsilon_{k,i}=Y_{k,i}-\bar Y_{k,s},$9, the mote immediately beacons its new state so neighbors can estimate $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$0, then wakes periodically to collect up to $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$1 distinct neighbor-segment anchors, and stores these anchor pairs on flash until the basestation harvest (Gupchup et al., 2019). Thus each segment gathers anchors immediately after reboot and later in time to support both offset and skew estimation.

The reported accuracy is “up to 6 ppm for 99% of the collected measurements,” and Phoenix is able to maintain this performance for periods lasting for months without a persistent global time source (Gupchup et al., 2019). In simulation, end-to-end PPM error stays under 6 ppm for 99% of samples, median $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$2 error is below 6 ppm even if the GPS-equipped mote is absent for up to 150 days, and data loss is below 0.3% with a single GPS mote offline for months. In the 21-day Olin deployment, median $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$3 error is 1.7–5.9 ppm, median $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$4 error is 0.88–6.44 s, and data loss is below 0.06% for durations up to 18 days; in the 35-day Brazil deployment, Phoenix timestamps 99.7% of 5.4 M samples (Gupchup et al., 2019). The additional overhead is reported as approximately 4% flash and approximately 0.2% duty cycle.

A common misconception would be to treat “reboot” here as a learning metaphor analogous to the bandit or RL papers. The Phoenix setting is different: the problem is physical device reboot, loss of volatile clock state, and postmortem reconstruction of a global timeline (Gupchup et al., 2019).

4. Mostly-automatic translation of C interpreters into safe Rust

In programming languages and software security, Reboot is a system for mostly-automatic, end-to-end translation of C-based language interpreters into safe Rust (Wang et al., 25 Jun 2026). The target is not retraining or exploration but migration of systems software under strict ownership and borrowing constraints. The stated goals are to produce a Rust translation that compiles as 100% “safe” Rust with no unsafe blocks or raw pointers, passes the interpreter’s existing test suite, retains or improves correctness on unseen tests, and requires only minimal human intervention (Wang et al., 25 Jun 2026).

The design combines feature reduction and a multi-agent workflow. Feature reduction first analyzes the C source to identify interpreter features and their dependencies, producing a monotonic sequence of feature levels

$$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$5

where $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$6 is minimal functionality and $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$7 is the full interpreter (Wang et al., 25 Jun 2026). Starting from the original interpreter $$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$8, the system iteratively removes features to obtain reduced but still complete interpreters

$$\epsilon_{k,s+1}=+\sqrt{s+2}\,\alpha_a,\qquad \epsilon_{k,s+2}=-\sqrt{s+2}\,\alpha_a.$$9

Translation then begins from the simplest version and restores features incrementally:

$T$00

At each step, the original test suite is adapted to the current feature set, and line coverage should not drop by more than a small $T$01, for example 3%, relative to the previous level (Wang et al., 25 Jun 2026).

The multi-agent architecture organizes specialized workers and a Manager agent enforcing a finite-state-machine protocol. In the feature-reduction subsystem, Simplifier removes code for a feature, Validator runs C tests and checks coverage and “no remnants,” Cleanup tidies diffs and commits, and the Manager orchestrates precheck, simplification, validation, and cleanup (Wang et al., 25 Jun 2026). In the translation subsystem, Translator produces Rust code, Test-Validator runs tests and detects cheating such as hardcoded returns, CodeReviewer enforces safe Rust and absence of unsafe, Cleanup formats and commits, and the Manager again loops through setup, translation, validation, review, and cleanup.

Worker outputs are treated as unreliable. Each worker returns a status label

$T$02

but Reboot uses an automated validity check $T$03 and history-feedback $T$04 to detect hallucination, non-progress, or loops (Wang et al., 25 Jun 2026). If status and reality disagree, or if the same ineffective pattern repeats, the manager refines prompts or escalates. Reported escalation logic includes automatic revalidation of claimed completions, escalation of all INFEASIBLE cases, restart or escalation on ERROR, and loop detection from history.

Empirically, Reboot translated six interpreters ranging from 6 k to 23 k lines of C code—awk, gnu-bc, picoc, wren, mujs, and pocketpy—with wall-clock translation times of 28 h to 90 h and monetary cost of \$T$051 780 per interpreter (Wang et al., 25 Jun 2026). All translations pass 100% of the provided test suites. On unseen validation tests, pass rates range from 61.6% for pocketpy to 91.8% for wren. On the ECMA-262 ES5 Test262 subset used for mujs, the translated Rust version passes 8,268/9,853 tests, compared to 9,853/9,853 for the C version (Wang et al., 25 Jun 2026).

Human intervention is limited but nonzero. Across the six translations, the counts are awk (1), gnu-bc (1), picoc (4), wren (8), mujs (4), and pocketpy (11), for a total of 29 interventions at approximately 5 min on average (Wang et al., 25 Jun 2026). The paper also reports 125 escalations auto-resolved by a “User Delegator Agent,” forwarding only 29 to the human. Intervention scenarios include task clarification, workflow clarification, agent misbehavior correction, design decisions, and system issues.

The security case study on mujs is central to the system’s motivation. Twenty CVEs were reintroduced into the C baseline: heap buffer overflows, use-after-free, stack buffer overflow, global overflow, out-of-bounds read, null-pointer dereference, integer overflow, stack exhaustion DoS, and bytecode logic errors (Wang et al., 25 Jun 2026). Rust’s ownership and borrowing, bounds checking, type safety, safe APIs, architectural redesign, and Result/?-based error propagation are reported to eliminate or mitigate many of these vulnerabilities. The status summary is 14/20 eliminated, 4/20 mitigated, and 2/20 unmitigated, with the remaining cases corresponding to stack exhaustion bugs that survive in safe Rust recursion (Wang et al., 25 Jun 2026).

The ablation study is especially important for understanding the name. Reboot without feature reduction, described as “MAS only,” performs worse: unseen-test pass rates drop from 74.8% to 65.6% on mujs, from 69.5% to 49.0% on picoc, from 78.8% to 71.9% on awk, from 78.6% to 67.5% on gnu-bc, and from 91.8% to 85.6% on wren, while pocketpy fails without reduction (Wang et al., 25 Jun 2026). This suggests that in this domain “reboot” refers to restarting the translation process from a deliberately simplified program and then rebuilding functionality through validated milestones.

5. Fully encrypted deep learning with CKKS bootstrapping

In privacy-preserving machine learning, ReBoot is a framework for fully encrypted and non-interactive training of deep neural networks under the CKKS homomorphic encryption scheme (Pirillo et al., 24 Jun 2025). The paper positions the method against a background in which encrypted training had largely been restricted to logistic regression or had required multi-party computation for model fine-tuning. ReBoot instead targets arbitrarily deep multi-layer perceptrons by combining a local-loss architecture, SIMD-aware packing, and approximate CKKS bootstrapping (Pirillo et al., 24 Jun 2025).

CKKS is presented as an approximate arithmetic scheme over real and complex vectors with post-quantum security under standard RLWE hardness assumptions, batching up to $T$06 real numbers into one ciphertext (Pirillo et al., 24 Jun 2025). A plaintext is

$T$07

and a ciphertext is

$T$08

encrypting $T$09 by

$T$10

Because CKKS is leveled, each multiplication consumes one level and adds noise, so without refreshing, noise eventually overwhelms the plaintext (Pirillo et al., 24 Jun 2025).

Approximate bootstrapping restores ciphertext level rather than resetting noise to the encryption-noise floor. The paper describes modulus switching, approximate evaluation of modular reduction,

$T$11

and re-encoding to rebuild the CKKS structure (Pirillo et al., 24 Jun 2025). The bootstrapped ciphertext encrypts the same message up to approximation error, and the paper states that one achieves $T$12 with $T$13 multiplications. ReBoot performs two successive bootstrappings after each weight update.

The neural architecture departs from standard backpropagation by partitioning the network into local-loss blocks $T$14 (Pirillo et al., 24 Jun 2025). Each block contains a fully connected layer, a polynomial activation

$T$15

and a local linear classifier mapping the block’s activation to output classes. Each block computes its own local gradient against the true label and updates only its own weights; gradients do not flow between blocks (Pirillo et al., 24 Jun 2025). The paper states that this bounds the maximum multiplicative depth by the depth within one block rather than making it proportional to $T$16. Its worst-case forward depth per iteration is

$T$17

whereas backpropagation grows as approximately $T$18.

Packing is central to computational efficiency. ReBoot fixes two dimensions $T$19 with $T$20 and uses repeated and expanded vector formats together with row-encoded and column-encoded matrices (Pirillo et al., 24 Jun 2025). Matrix-vector multiplication is realized by REMatMul and CEMatMul, both based on slotwise products followed by tree-sums using rotations and additions. The paper states that REMatMul has depth 1 and CEMatMul has depth 2. Per block, forward propagation uses one REMatMul, one activation, and one CEMatMul, while backward propagation uses slotwise products, one REMatMul, one activation-derivative step, and the encrypted weight update, giving depth 4–5 (Pirillo et al., 24 Jun 2025).

The reported empirical results cover image and tabular benchmarks, including MNIST, Fashion-MNIST, Kuzushiji-MNIST, C-MNIST, T-MNIST, Letter, Breast Cancer, Heart Disease, Penguins, and Iris (Pirillo et al., 24 Jun 2025). On MNIST binary classification, encrypted logistic regression reaches 96.4% test accuracy, while ReBoot with eMLP-1 [784–32–10] reaches $T$21, an improvement of $T$22. Relative to prior encrypted DNNs, ReBoot reports 97.67% on MNIST [784–128–32–10] versus Glyph’s 96.60%, 96.71% on C-MNIST [64–32–16–10] versus BGV ’19 at 96.00%, 93.39% on T-MNIST using eMLP-1 versus tBMPNet’s 91.90%, 89.08% on Fashion-MNIST [784–200–10] versus tBMPNet’s 86.00%, and 99.69% on Iris [4–10–3] versus PrivFT’s 98.05% (Pirillo et al., 24 Jun 2025). The paper summarizes these as up to $T$23 over existing encrypted DNN frameworks.

Latency is also quantified. On a $T$24 Xeon workstation, tBMPNet ’21 in TFHE takes 1681.2 s per iteration on [1–1–1], while ReBoot in bootstrapped CKKS takes 198.4 s, described as an $T$25 speedup; for [4–2–3], ReBoot takes 193.8 s versus TFHE’s 646.7 s, a $T$26 speedup (Pirillo et al., 24 Jun 2025). The paper further states that width is essentially “free” until the slot limit because SIMD packing prevents latency from scaling linearly with layer width.

A frequent confusion would be to equate the “boot” in ReBoot with ordinary restart or retraining. The paper uses the term specifically in the homomorphic-encryption sense: approximate bootstrapping restores modulus space so that further encrypted multiplications remain possible, while the local-loss design limits noise accumulation (Pirillo et al., 24 Jun 2025).

6. Shared structure and semantic divergence

Across these works, “reboot” is not a single paradigm but a family resemblance among restart-oriented designs. In bandits, the restart concerns uncertainty quantification from residuals rather than priors or hand-designed bonuses (Wang et al., 2020, Wu et al., 2022). In dexterous RL, it concerns initializing learning for a new task from a prior replay buffer and closing the real-world training loop with learned resets and learned rewards (Hu et al., 2023). In sensor networks, it refers to actual device reboots that erase clock state and motivate epidemic reconstruction of temporal relationships (Gupchup et al., 2019). In program translation, it describes a disciplined restart from feature-reduced interpreters and a managed recovery process for unreliable coding agents (Wang et al., 25 Jun 2026). In encrypted learning, it refers to cryptographic bootstrapping and to an architecture designed so encrypted optimization can proceed beyond the multiplicative-depth limit (Pirillo et al., 24 Jun 2025).

Several objective distinctions follow. First, the term is used both literally and metaphorically. Phoenix addresses literal mote reboots, whereas the other papers use “ReBoot” or “REBOOT” as method names for residual resampling, data reuse, translation staging, or bootstrapped ciphertext refresh (Gupchup et al., 2019, Wang et al., 2020, Hu et al., 2023, Wang et al., 25 Jun 2026, Pirillo et al., 24 Jun 2025). Second, “bootstrapping” itself has domain-specific semantics: empirical residual resampling in bandits, replay-buffer initialization in RL, and modulus-refresh in CKKS are not interchangeable operations. Third, the performance criteria differ sharply by field: regret bounds and anti-concentration in bandits, wall-clock training time and success rates in dexterous manipulation, ppm timestamp error in sensor networks, pass rates and CVE elimination in interpreter translation, and encrypted accuracy-speed trade-offs in HE training.

This suggests that the unifying editorial meaning of “reboot” is structured recovery under constraints. The relevant constraints are small-sample exploration, scarce robot interaction time, loss of clock state, unreliable autonomous coding agents, and finite homomorphic multiplicative depth. The literature does not present these as a single research lineage, but it consistently uses the name for systems that recover useful behavior by preserving and reusing internal structure rather than starting from nothing.