Argument-Swap Protocol

• Argument-swap protocol is a unifying schema that defines when two operands should be exchanged or retained, using domain-specific decision mechanisms and correctness criteria.
• In software, static-analysis tools use both cover-based morpheme checks and statistical methods to detect accidental argument swaps with improved precision through combined heuristics.
• In quantum and blockchain systems, controlled swap operations and cryptographic predicates enable reliable state exchange, ensuring operational fidelity and secure asset transfers.

In the cited literature, an argument-swap protocol is not a single standardized formalism but a recurring pattern in which two semantically distinct operands are preserved, exchanged, compared, or conditionally transferred under explicit correctness constraints. In software analysis, the relevant object is the accidental interchange of positional arguments at a call site. In quantum information and structured-light systems, it is the controlled exchange of registers or amplitudes by SWAP, c-SWAP, $\sqrt{\mathrm{SWAP}}$, or $\sqrt{i\text{SWAP}}$-type interactions. In networking and blockchain systems, it is the rule-governed exchange of entanglement resources or escrowed assets across a graph. Taken together, these works suggest that an argument-swap protocol is best understood as a protocol schema for deciding when two positions should remain fixed, when they should be exchanged, and how that decision is certified by names, measurements, capacities, or cryptographic conditions (Scott et al., 2020, Szatkowski et al., 2020, Dai et al., 2021, Xue et al., 2022).

1. Core abstraction

A common formal pattern appears across otherwise unrelated domains. In the software-analysis setting, a call $f(a_1,\dots,a_n)$ is problematic when arguments at positions $i$ and $j$ correspond semantically better to parameters $p_j$ and $p_i$ than to $p_i$ and $p_j$. In the standard quantum setting, a controlled-SWAP gate acts on basis states by

$$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$

while the SWAP test transforms state overlap into a measurable control probability,

$\sqrt{i\text{SWAP}}$0

These formulations differ in ontology, but each isolates two payloads, a control or evidence mechanism, and a correctness criterion for exchange versus non-exchange (Scott et al., 2020, Szatkowski et al., 2020).

This suggests a unifying abstraction with three recurrent elements. First, there are two candidate “arguments,” broadly construed as call-site values, quantum subsystems, queued resources, or escrowed assets. Second, there is a decision mechanism, such as morpheme-level coverage, corpus statistics, a Hadamard-controlled interference pattern, a scheduling rule, or a hashlock circuit. Third, there is an application-specific notion of acceptable outcome: semantic alignment in code, large state overlap or exact SWAP in physics, bounded backlog in networking, or safety and liveness predicates in blockchain protocols.

2. Static-analysis protocols for swapped call arguments

In software engineering, the argument-swap problem arises in languages with positional arguments when two parameters share the same or compatible types and the call accidentally uses a non-canonical order. The motivating examples include signatures such as int kill(pid_t pid, int sig); followed by a call like kill(SIGKILL, cpid);, where the program type-checks but the process ID and signal are semantically interchanged. “Out of Sight, Out of Place: Detecting and Assessing Swapped Arguments” implements a static-analysis checker, SwapD, that exploits natural-language information in code rather than relying only on types or control/data flow. It extracts identifier names from AST nodes, splits them into morphemes with Ronin, compares argument and parameter morphemes with a domain-adapted similarity relation $\sqrt{i\text{SWAP}}$1, and combines two independent detectors: a cover-based checker and a statistical checker (Scott et al., 2020).

The cover-based checker defines

$\sqrt{i\text{SWAP}}$2

where $\sqrt{i\text{SWAP}}$3 and $\sqrt{i\text{SWAP}}$4 are the morpheme sets of argument $\sqrt{i\text{SWAP}}$5 and parameter $\sqrt{i\text{SWAP}}$6. A candidate swap between positions $\sqrt{i\text{SWAP}}$7 and $\sqrt{i\text{SWAP}}$8 is produced when

$\sqrt{i\text{SWAP}}$9

but

$f(a_1,\dots,a_n)$0

The statistical checker instead uses corpus counts $f(a_1,\dots,a_n)$1 over triples $f(a_1,\dots,a_n)$2 and the relative-frequency score

$f(a_1,\dots,a_n)$3

requiring, among other conditions, that $f(a_1,\dots,a_n)$4 with $f(a_1,\dots,a_n)$5. Cover-based candidates are then statistically vetted and filtered by heuristics, including white-list words such as swap, exchange, rotate, and flip, a maximum swap distance $f(a_1,\dots,a_n)$6, geometric-pattern suppression, type checks, nearby declaration checks, nearby correct-call checks, and repeated swap-frequency checks within a caller. On 6541 Fedora 29 SRPM C/C++ projects totaling approximately 417 million lines of code, the full configuration $f(a_1,\dots,a_n)$7 achieved precision $f(a_1,\dots,a_n)$8 with yield $f(a_1,\dots,a_n)$9 true positives; $i$0 achieved precision $i$1 with yield $i$2. Across configurations, 4141 unique warnings were generated, 859 were manually triaged, and 183 were classified as true positives. The paper reports that 42% of the true positives involved names with more than one morpheme, and that the cover-based and statistical detectors had only modest overlap, with 15 shared true positives, so their combination materially increased coverage (Scott et al., 2020).

3. Controlled-SWAP and SWAP-test protocols

In quantum information, the canonical argument-swap primitive is the controlled-SWAP or Fredkin gate, together with the SWAP test. The SWAP test prepares the control qubit in $i$3, applies a Hadamard, performs a c-SWAP on $i$4 and $i$5, applies a second Hadamard, and measures the control. The resulting outcome statistics satisfy $i$6, so repeated trials estimate overlap without full state tomography. “Implementation of a simultaneous message passing protocol using optical vortices” realizes a classical optical analog of this construction with structured light, using Laguerre–Gauss modes, polarization as the control, positive OAM indices $i$7 for Alice, and negative indices $i$8 for Bob (Szatkowski et al., 2020).

The optical protocol maps one control polarization to an even number of reflections and hence no OAM helicity flip, while the orthogonal polarization undergoes an odd number of reflections and therefore $i$9, which exchanges Alice’s and Bob’s channels. After the two Hadamard-equivalent half-wave plates and the polarization-sensitive Mach–Zehnder interferometer, the output powers obey

$j$0

with overlap parameter

$j$1

For binary phase encoding $j$2, this simplifies to

$j$3

where $j$4 is the fraction of equal bits. The implemented system used one OAM channel per sender and many bits via time-division multiplexing, operated a digital micromirror device with a maximum rate of $j$5 kHz and an effective modulation rate of $j$6 kHz, and achieved approximately 40 time bins per detector integration window, corresponding to 40-bit messages per sender per comparison. The study reports comparisons for overlap values from 0% to 100% in 10% steps, together with a two-reference normalization scheme that used 100% and 0% overlap reference blocks to correct for drift and interferometric imbalance. A recurrent misconception is that this optical simultaneous message-passing protocol inherits quantum security from the SWAP test; the paper explicitly distinguishes it as a classical, quantum-mimetic implementation whose privacy-preserving character is logical rather than guaranteed by no-cloning or measurement disturbance (Szatkowski et al., 2020).

4. Exchange gates, partial swaps, and bidirectional state transfer

A second major line of work treats argument-swap as a coherent exchange interaction rather than as a comparison test. In superconducting transmon architectures, “High-fidelity $j$7 gates using a fixed coupler driven by two microwave pulses” studies two fixed-frequency qubits $j$8 coupled through a fixed-frequency transmon coupler $j$9, with only the coupler driven. The induced two-qubit gate has the form

$p_j$0

and $p_j$1 gives exactly $p_j$2. The protocol uses two microwave tones on the coupler, tuned near two-photon resonances involving the coupler’s second excited state, together with smoothed flat-top Gaussian pulses. For the ABA architecture the paper reports fidelity $p_j$3 after single-qubit phase compensation and $p_j$4 for a $p_j$5-like target including a conditional phase $p_j$6 rad; for the ABC architecture it reports $p_j$7 and $p_j$8, respectively, with $p_j$9 rad (Xu et al., 2024).

A more representation-theoretic version appears in “The Power of Power-of-SWAP: Postselected Quantum Computation with the Exchange Interaction,” which defines exchange gates

$p_i$0

so that $p_i$1 and $p_i$2. The paper introduces XQP circuits, consisting of computational-basis SPAM and exchange interactions only, and proves

$p_i$3

It further shows that efficient multiplicative-error simulation of XQP would collapse the polynomial hierarchy to its third level, that random $p_i$4-only circuits form unitary $p_i$5-designs over $p_i$6-invariant unitaries with $p_i$7, and that the entangling power of $p_i$8 is

$p_i$9

maximized at $p_i$0 (Burkat et al., 30 Mar 2026).

A third variant dispenses with universal local control and uses scrambling. “Bidirectional teleportation using scrambling dynamics: a practical protocol” considers collective subsystems $p_i$1, global scramblers $p_i$2 and $p_i$3, and a postselection on subsystem $p_i$4. The effective map

$p_i$5

approximates $p_i$6 when the mediator dimension satisfies $p_i$7, with average postselection probability $p_i$8 in the optimal regime. The paper also proves a general dimension-dependent limitation: for $p_i$9 and $p_j$0, there exists an input state with SWAP fidelity bounded by

$p_j$1

The proposed implementation uses Dicke-type spin–boson dynamics in cavity-QED or trapped-ion systems, thereby making bidirectional state exchange an experimentally motivated protocol rather than only a circuit identity (Vikram et al., 21 Jan 2026).

5. Resource-swapping in quantum networks

In quantum networking, swapping is a scheduling and queueing operation rather than a gate applied to two qubits in isolation. “Entanglement Swapping in Quantum Switches: Protocol Design and Stability Analysis” studies a star topology with one quantum switch and $p_j$2 end nodes. Link-level Bell pairs $p_j$3 arrive at rates $p_j$4, entanglement requests $p_j$5 enter queues $p_j$6, and the switch chooses swap attempts $p_j$7, each succeeding with probability $p_j$8, subject to the resource constraints

$p_j$9

The capacity region is characterized by flow variables $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$0 satisfying

$$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$1

Stability is defined through

$$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$2

with stability requiring $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$3 as $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$4. The paper develops stationary protocols, on-demand protocols that need not know $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$5, $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$6, or $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$7, and an on-demand protocol with virtual requests

$$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$8

which achieves zero average latency under stronger assumptions. In discrete-event simulations with $$|c,a,b\rangle \mapsto \begin{cases} |0,a,b\rangle, & c=0,\ |1,b,a\rangle, & c=1, \end{cases}$$9 or $\sqrt{i\text{SWAP}}$00, slot length $\sqrt{i\text{SWAP}}$01 ns, $\sqrt{i\text{SWAP}}$02, $\sqrt{i\text{SWAP}}$03, memory slots per interface of 100, and $\sqrt{i\text{SWAP}}$04 ms, the on-demand protocols were reported as computationally efficient and as achieving high fidelity and low latency (Dai et al., 2021).

6. Predicate-based asset swaps and HTLC characterizations

In distributed-ledger systems, an argument-swap protocol becomes a cryptographically enforced exchange of assets across a directed graph. “Invited Paper: Fault-tolerant and Expressive Cross-Chain Swaps” models a swap as a strongly connected digraph $\sqrt{i\text{SWAP}}$05, with a Boolean variable for each arc and a predicate for each participant. The general safety predicate is

$\sqrt{i\text{SWAP}}$06

and the liveness predicate is

$\sqrt{i\text{SWAP}}$07

Global solutions satisfy

$\sqrt{i\text{SWAP}}$08

and each satisfying assignment defines a feasible swap digraph $\sqrt{i\text{SWAP}}$09. The paper introduces redundancy providers, conflicting solutions, and two protocols. ProtocolA is described as high collateral and fast settlement: it computes all satisfying solutions, builds swap schemes for them, runs escrow in parallel, and then selects a maximal non-conflicting subset $\sqrt{i\text{SWAP}}$10 for redeem. ProtocolB is low collateral and fixed time: it augments each predicate with an exclusivity constraint $\sqrt{i\text{SWAP}}$11, imposes an ordering $\sqrt{i\text{SWAP}}$12, and uses priority-sensitive circuits

$\sqrt{i\text{SWAP}}$13

The point of both constructions is that acceptable subsets of swaps can still complete even when some parties deviate, rather than enforcing only an all-or-nothing outcome (Xue et al., 2022).

A more restrictive but sharper line of work asks when standard HTLCs suffice. “On HTLC-Based Protocols for Multi-Party Cross-Chain Swaps” shows that an atomic HTLC-based protocol exists if and only if the swap digraph is a reuniclus digraph. In the single-secret case, the exact class is the bottleneck digraphs. The paper defines bottleneck digraphs as strongly connected digraphs with a vertex lying on every cycle, gives the BDP protocol for that case using distances $\sqrt{i\text{SWAP}}$14, $\sqrt{i\text{SWAP}}$15, and timeouts

$\sqrt{i\text{SWAP}}$16

and generalizes to reuniclus digraphs with RDP, using bottleneck components arranged in a rooted tree, the distance parameter $\sqrt{i\text{SWAP}}$17, and timeouts

$\sqrt{i\text{SWAP}}$18

The main negative result is equally important: HTLC-only mechanisms are not sufficient for arbitrary strongly connected digraphs under the paper’s model, so atomic multi-party swap design has a sharp topological boundary (Clark et al., 2024).

7. Comparative perspective and limitations

A recurrent misconception is that any swap primitive is interchangeable with any other. The literature instead records domain-specific notions of evidence, correctness, and feasibility. In software, SwapD is heuristic and depends on meaningful identifier names, English-like morphemes, empirically chosen thresholds, and the assumption that most code in the corpus is correct; it is explicitly limited by naming quality, macro complexity, and the possibility that false-positive filters suppress real bugs (Scott et al., 2020). In structured-light simultaneous message passing, the measurement yields a global similarity metric without bitwise readout, but the implementation uses classical intense light and therefore does not inherit the physical privacy guarantees of quantum fingerprinting (Szatkowski et al., 2020).

Quantum gate constructions also separate naturally into different regimes. Exchange-only models such as XQP are sub-universal without postselection yet remain hard to simulate under standard complexity assumptions; this places them in an intermediate regime rather than identifying them with unrestricted BQP (Burkat et al., 30 Mar 2026). Scrambling-based SWAP protocols succeed only probabilistically and require a mediator dimension scaling as $\sqrt{i\text{SWAP}}$19 for high-fidelity generic SWAP, so global interactions alone do not remove capacity constraints (Vikram et al., 21 Jan 2026). In blockchain settings, standard atomicity and fault tolerance are not the same property: all-or-nothing protocols can be safe while still failing to complete any acceptable subset after deviation, whereas predicate-based protocols address precisely that gap; conversely, when one restricts the execution layer to standard HTLCs, expressiveness is lost and only reuniclus digraphs admit atomic protocols (Xue et al., 2022, Clark et al., 2024).

Taken as a whole, the cited work supports a precise but plural understanding of argument-swap protocols. They are protocols whose central operation is an exchange decision between two positions, but the surrounding theory depends on the substrate: morpheme semantics in static analysis, interference and overlap in optical and quantum systems, flow constraints in network switches, and predicates plus cryptographic timing in distributed ledgers. The term therefore names a family of protocol designs rather than a single canonical construction.