CutOnce: One-Time Decisions Across Domains

• CutOnce is a multi-disciplinary concept that enforces a one-time, irreversible decision in domains such as quantum cryptography, image augmentation, dataset condensation, and circuit cutting.
• It shifts intricate computations to an initial phase—using methods like probabilistic one-time programs and single-pass augmentations—to simplify downstream processing.
• Applications include secure quantum token evaluation, enhanced image and object processing, efficient dataset pruning, and reduced overhead in quantum circuit decompositions.

CutOnce is not a single standardized concept. In contemporary research usage, the name has been attached to several technically distinct ideas that share a common constraint: a decisive action is performed once, and later computation, inference, or allocation must respect that one-time choice. In quantum cryptography, CutOnce denotes physically single-use software implemented through probabilistic one-time programs; in computer vision and representation learning, it denotes single-cut image augmentation and single-pass object discovery; in dataset condensation, it denotes condense-once-then-prune workflows; and in quantum circuit cutting, it denotes schemes that reduce or restructure the cost of severing nonlocal dependencies (Roehsner et al., 2020, Han et al., 2022, He et al., 2023, Feng et al., 4 Aug 2025).

1. Terminological scope

The term is best understood as a family resemblance rather than a unified formalism. In some domains, “once” refers to irreversible physical consumption; in others, it refers to a one-time preprocessing stage, a single graph partition, or a single cut operation whose downstream effects are handled classically.

Domain	Meaning of “CutOnce”	Representative papers
Quantum cryptography	Single-use evaluation of software or authority tokens	(Roehsner et al., 2020)
Vision and learning	One image cut, one NCut pass, or condense once then resize	(Han et al., 2022, He et al., 2023, Feng et al., 4 Aug 2025)
Quantum circuit cutting	Reduce the cost of cut channels, joint gate cuts, or cut-aware decompositions	(Chen et al., 2023, Schmitt et al., 2023, Tamura et al., 27 Mar 2026, Marshall et al., 2023)

This diversity matters because superficially similar language can hide incompatible technical objectives. A cryptographic CutOnce scheme is concerned with information-theoretic single-use; a vision CutOnce method is concerned with augmentation diversity or object-mask extraction; a circuit-cutting CutOnce method is concerned with sampling overhead.

2. Quantum single-use software

In "Probabilistic one-time programs using quantum entanglement" (Roehsner et al., 2020), CutOnce denotes a literal single-use execution model. A one-time program lets a sender supply a receiver with a way to evaluate a function $f(x)$ exactly once while revealing no more than the single input-output pair $(x,f(x))$, and while keeping both software and input private up to what is implied by that pair. Since information-theoretically perfect one-time programs are impossible without self-destructing hardware, the construction is probabilistic rather than perfect. For the $1$-bit-to-$1$-bit gate set $G_1$, the per-gate success probability is

$$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$

with $P_{\mathrm{err}} \approx 0.1464$, and for general $k$-input classical gates $G_k$ the success probability scales as

$P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$

The single-use property is enforced by measurement incompatibility. Bob chooses an input by choosing a measurement basis: input $(x,f(x))$0 corresponds to measuring in $(x,f(x))$1, input $(x,f(x))$2 to measuring in $(x,f(x))$3, and output bits are assigned from the $(x,f(x))$4 eigenstates. Because $(x,f(x))$5 and $(x,f(x))$6 anti-commute, learning the output for one input excludes later recovery of the output for the other input on the same token. No-cloning and irreversible measurement disturbance supply the physical enforcement, while logical enforcement is completed by deleting consumed rows from the shared classical table.

The entanglement-based improvement separates the quantum distribution phase from a later classical execution phase. Alice distributes Bell-pair correlations, measures her half in one of two bases, and thereby remotely prepares on Bob’s side one of four single-qubit states encoding the four $(x,f(x))$7 gates. The resulting resource is an i.i.d. shared table: Alice records which random gates were sent, Bob records which inputs and outputs were obtained. Later execution uses only classical communication. Alice chooses a one-time pad bit $(x,f(x))$8, proposes a row index, Bob accepts only if the row matches the needed input, Alice reveals $(x,f(x))$9, and Bob flips the output if $1$0. Optional privacy of intermediate wires is obtained by inserting random NOT pairs with probability $1$1 and absorbing them into adjacent gates.

Experimentally, the protocol was demonstrated over approximately $1$2 of standard single-mode telecom fiber between university buildings in Vienna, with measured end-to-end transmission $1$3. The source prepared $1$4 pairs, the observed coincidence rate was approximately $1$5, and this represented about a $1$6 improvement over earlier prepare-and-measure OTP experiments at approximately $1$7. Bell-state quality was reported as visibility $1$8 in the linear basis and $1$9 in the diagonal basis, with fidelity lower bound $1$0. A sacrificed subset of rows supported eavesdropper detection through a CHSH test with $1$1, violating the classical bound by $1$2. The same framework was used for one-time delegation of signature authority with $1$3, $1$4, measured per-gate success $1$5, honest success probability approximately $1$6, and cheating probability approximately $1$7 for the worst-case two-message attack differing in one hash bit. The principal limitations remain probabilistic correctness, loss-driven throughput reduction, table storage and synchronization, and the cost of sacrificing rows for CHSH testing.

3. Single-cut learning in vision

In "You Only Cut Once: Boosting Data Augmentation with a Single Cut" (Han et al., 2022), CutOnce is a parameter-free augmentation wrapper. An image is cut into two equal halves along height or width with equal probability, the same augmentation family is applied independently to each half with independent randomness, and the pieces are concatenated back into one image. Unlike CutOut or CutMix, the method does not remove content or paste cross-image content; it preserves the full image content and changes only the augmentation scope. Its stated motivation is to increase per-sample diversity and to encourage recognition from partial information. The paper reports improvements in 76 of 84 CIFAR-10 settings and 68 of 84 CIFAR-100 settings across seven architectures and twelve augmentation configurations. On ImageNet, examples include an AutoAug last-epoch gain of $1$8, an AutoAug partial-recognition gain of $1$9, and a Mixup calibration RMS drop from $G_1$0 to $G_1$1. The paper also reports modest gains in contrastive pretraining, such as MoCo v2 linear-eval top-1 improving from $G_1$2 to $G_1$3 and SimSiam from $G_1$4 to $G_1$5. A recurrent caveat is that YOCO can hurt horizontal-flip augmentation on iconic-object datasets and can degrade adversarial robustness when applied to color-based transforms.

In "You Only Condense Once: Two Rules for Pruning Condensed Datasets" (He et al., 2023), the same abbreviation YOCO is repurposed for dataset condensation. Here “once” refers to the condensation stage rather than the pruning stage. A single condensed dataset $G_1$6 of size $G_1$7 images per class is created once, and then resized to target budgets $G_1$8 by post hoc pruning rather than re-condensation. The two rules are Low LBPE Score and Balanced Construction. The scoring signal is

$G_1$9

averaged over the Top-$$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$0 epochs with highest training accuracy:

$$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$1

The selection rule keeps low-LBPE synthetic samples first, while enforcing equal per-class quotas. The paper positions this as particularly suited to tiny condensed regimes and on-device settings where recomputing condensation is prohibitive. On CIFAR-10 with $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$2, YOCO reports $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$3 average accuracy over $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$4, compared with $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$5 for IDC, $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$6 for DREAM, and $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$7 for CCS. In the CIFAR-10 IPC10$$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$81 ablation, IDC baseline is $$P_s = \frac{1}{2} + \frac{1}{2\sqrt{2}} \approx 0.8536,$$9, Balanced only is $P_{\mathrm{err}} \approx 0.1464$0, LBPE only is $P_{\mathrm{err}} \approx 0.1464$1, and LBPE plus Balanced reaches $P_{\mathrm{err}} \approx 0.1464$2.

In "Enhancing Object Discovery for Unsupervised Instance Segmentation and Object Detection" (Feng et al., 4 Aug 2025), CutOnce is the first stage of COLER. A DINO ViT-B/8 backbone extracts token features from a $P_{\mathrm{err}} \approx 0.1464$3 image, a graph is built with density-tuned affinities, and Normalized Cut is applied only once. The second smallest eigenvector is sign-corrected, thresholded at its mean, boundary-augmented through

$P_{\mathrm{err}} \approx 0.1464$4

and converted into multiple candidate instances by 4-connected components plus a ranking rule that keeps top components until a cumulative saliency fraction $P_{\mathrm{err}} \approx 0.1464$5 is reached. The method does not rely on clustering or recursive graph partitioning, yet can generate more than ten masks. Reported mask-generation time is approximately $P_{\mathrm{err}} \approx 0.1464$6. As a train-free pseudo-mask generator, CutOnce reports ImageNet-val $P_{\mathrm{err}} \approx 0.1464$7 and COCO-val2017 $P_{\mathrm{err}} \approx 0.1464$8. The downstream COLER detector, trained on these pseudo labels and then self-trained once, reports on COCO val2017 $P_{\mathrm{err}} \approx 0.1464$9, $k$0, $k$1, and $k$2.

4. Circuit cutting and the limits of “cutting once”

In quantum circuit cutting, CutOnce refers less to a branded algorithm than to an objective: reduce the effective cost of severing nonlocal dependencies. "Efficient Quantum Circuit Cutting by Neglecting Basis Elements" (Chen et al., 2023) studies standard Pauli-basis wire cutting, where a single cut produces $k$3 measurement-preparation terms and $k$4 cuts scale as $k$5 Pauli strings with $k$6 upstream and $k$7 downstream eigenvalue branches. The key observation is that some Pauli directions pass no information for a given observable, as witnessed by

$k$8

Such directions can be pruned exactly. For a single cut, pruning one Pauli direction reduces the recombination from $k$9 to $G_k$0 terms and removes all downstream preparations for that direction. On IBM hardware, the paper reports a $G_k$1 wall-time reduction, from $G_k$2 to $G_k$3, with executions reduced from $G_k$4 to $G_k$5 and no loss of accuracy.

"Cutting circuits with multiple two-qubit unitaries" (Schmitt et al., 2023) addresses optimal quasiprobabilistic overhead when several two-qubit gates are cut jointly. For a two-qubit unitary with KAK coefficients $G_k$6, the optimal overhead is

$G_k$7

For $G_k$8 identical gates cut jointly,

$G_k$9

which is cheaper than cutting them individually. The paper shows that LO and LOCC have the same optimal overhead for two-qubit gate cutting. Concrete examples include $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$0, $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$1, and $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$2.

"Decomposition of Multi-Qubit Gates for Circuit Cutting" (Tamura et al., 27 Mar 2026) moves the optimization upstream, into the decomposition of MCX and CCCX gates after cut locations are identified. The central idea is to insert a small number of ancillas so that the partition boundary is crossed by as few primitives as possible. For CCCX, a standard $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$3-CNOT decomposition can produce eight crossing CNOTs for a partition between $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$4 and $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$5, giving overhead $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$6. The partition-aware dec2Ad construction reduces this to one crossing CNOT, with overhead $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$7 without classical communication and aggregate scaling $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$8 with classical communication, at the cost of leaving one ancilla dirty. The same pattern generalizes to MCX: the original multi-qubit interaction is decomposed into local MCX blocks in the two partitions plus a single cross-boundary CNOT.

These optimizations coexist with strong negative results. "All this for one qubit? Bounds on local circuit cutting schemes" (Marshall et al., 2023) proves that if there were a polynomial-time classical algorithm producing polynomial-size locally acting decompositions that efficiently cut even a single qubit from arbitrary circuits, then $P_k = \frac{1}{2} + \frac{1}{2^{1+k/2}}.$9. In the universal regime, exact local decompositions can require

$(x,f(x))$00

and the paper also shows that no circuit cutting scheme can work using only unital channels. The practical implication is that CutOnce-style savings in circuit cutting are real but sharply constrained: they reduce constants, bases, or special-case overheads, not the fundamental worst-case hardness of generic local cutting.

5. Single-pass and single-action motifs in adjacent fields

The same “once” motif appears in several adjacent literatures. In online fair division, "Online Cake Cutting" (Walsh, 2010) distinguishes per-agent and total cut complexity. The online Dubins–Spanier moving-knife procedure satisfies a natural per-agent CutOnce condition, because each agent can trigger at most one cut, while also achieving the minimal total of $(x,f(x))$01 cuts for contiguous sequential allocations. Online cut-and-choose also uses $(x,f(x))$02 physical cuts, but the same agent may cut multiple times. Online mark-and-choose gives each agent one marking action, although the number of physical cuts can exceed $(x,f(x))$03 if non-contiguous pieces are allowed. None of the online procedures is proportional, envy free, or equitable once departures occur before all arrivals.

In combinatorics, "Cut-Down de Bruijn Sequences" (Cameron et al., 2022) studies cyclic strings of length $(x,f(x))$04, $(x,f(x))$05, in which every length-$(x,f(x))$06 substring appears at most once. The paper gives $(x,f(x))$07-time, $(x,f(x))$08-space streaming constructions in both binary and $(x,f(x))$09-ary settings after initialization, as well as a successor-rule construction in the binary case. In dynamic graph algorithms, "Single pass sparsification in the streaming model with edge deletions" (Goel et al., 2012) gives a single-pass construction of $(x,f(x))$10-cut sparsifiers in insertion-deletion streams with $(x,f(x))$11 update time, $(x,f(x))$12 space, $(x,f(x))$13 recovery time, and $(x,f(x))$14 edges.

In programming-language analysis, "RedAlert: Determinacy Inference for Prolog" (Kriener et al., 2011) gives a semantics for cut in cut-normal form and derives a backward analysis that infers sufficient conditions for a goal to succeed at most once. For stratified programs, if

$(x,f(x))$15

then

$(x,f(x))$16

In graph theory, "Cut vertex and unicyclic graphs with the maximum number of connected induced subgraphs" (Dossou-Olory, 2020) does not use CutOnce as a formal method name, but it is closely tied to cut-vertex structure. The paper proves that maximizers of $(x,f(x))$17 among unicyclic graphs with fixed $(x,f(x))$18 and $(x,f(x))$19 cut vertices always have girth at most $(x,f(x))$20, with explicit triangle-based and square-based extremal templates.

6. Conceptual synthesis

Across these literatures, CutOnce is best read as a constraint on where complexity is allowed to appear. In the quantum one-time-program setting, complexity is pushed into the distribution phase and the irreversibility of incompatible measurements. In YOCO augmentation, complexity is pushed into local stochastic diversity after a single spatial split. In condense-once pruning, complexity is pushed into the original condensation run, so later resizing is cheap. In single-NCut object discovery, complexity is pushed into a single eigenproblem rather than recursive partitioning. In circuit cutting, complexity is redistributed from many cut channels to fewer or better-structured ones, although worst-case barriers remain.

Several common misconceptions are corrected by the technical details. A CutOnce augmentation does not necessarily remove information: YOCO retains the full image content after concatenation. A CutOnce condensation pipeline does not eliminate later computation: it replaces re-condensation with LBPE scoring and balanced selection. A CutOnce circuit-cutting strategy does not eliminate exponential overhead in general: it reduces overhead only under specific structure, symmetry, or decomposition choices, and lower bounds still apply. In the cryptographic setting, finally, CutOnce is not a metaphor; it is a physical single-use property enforced by anti-commuting measurements, no-cloning, and token consumption.

The recurring research value of the term is therefore methodological rather than lexical. CutOnce names designs in which one decisive cut, one decisive pass, or one decisive act is made structurally sufficient, and all later steps are forced to operate within that commitment.