Antisymmetrization of composite fermionic states for quantum simulations of nuclear reactions in first-quantization mapping

I present a first-quantization deterministic algorithm for antisymmetrizing a spatially separated target-projectile system containing $N_T$ and $N_p$ identical fermions, respectively. The method constructs a fully antisymmetric wavefunction from the product of two independently antisymmetrized many-body states, each of which may be a superposition of Slater determinants. The algorithm uses a Dicke-state ancilla register that coherently encodes all one-particle exchange channels between the two subsystems, and, crucially, requires only single-particle swaps to generate the full antisymmetric structure. A total of $O(N_T N_p)$ single-particle exchanges are needed, with up to $N_p$ of them implemented in parallel, if an additional $N_p$ ancillae are used. The correct fermionic phase is incorporated through application of $Z$ gates on $N_T$ ancillae, after which the ancilla register is efficiently uncomputed using a compact sequence of controlled operations. This construction provides a nontrivial and scalable protocol for preparing fully antisymmetric states in reaction and scattering simulations, significantly expanding the range of systems that can be addressed with first-quantized quantum algorithms.

💡 Research Summary

The paper introduces a deterministic, scalable quantum algorithm for preparing fully antisymmetric fermionic states that are required in first‑quantized simulations of nuclear reactions and scattering processes. The problem addressed is that, while one can independently antisymmetrize the target nucleus and the projectile nucleus (each possibly being a superposition of many Slater determinants), the tensor product of these two states is not antisymmetric under exchange of identical fermions that belong to different subsystems. Existing approaches either require ordering the single‑particle basis, rely on probabilistic success, or need to construct a full set of many‑particle permutations, all of which become prohibitive as the number of nucleons grows.

The core idea of the new method is to use a Dicke‑state ancilla register that encodes, in superposition, all possible ways of mapping the (N_{p}) projectile particles onto the combined set of (N_{T}+N_{p}) positions. The Dicke state (|D_{N_{T}+N_{p}}^{N_{p}}\rangle) is a uniform superposition of all bit‑strings with exactly (N_{p}) ones; each “1” marks a position that will be occupied by a projectile particle, while each “0” marks a target particle. By preparing this ancilla, the algorithm automatically selects the appropriate one‑particle exchange channels without having to enumerate them explicitly.

The antisymmetrization proceeds in three stages:

1. Dicke‑state preparation – Efficient circuits from the literature (e.g., using recursive amplitude amplification or combinatorial constructions) generate the required Dicke state using (O(N_{T}+N_{p})) depth and a linear number of ancilla qubits.

2. One‑particle swaps – For every pair of a target qubit and a projectile qubit, a controlled‑swap (or a sequence of three CNOTs) is applied conditioned on the corresponding ancilla bits (target‑ancilla = 0, projectile‑ancilla = 1). This implements the exchange of the two single‑particle states. The total number of such swaps is (N_{T}N_{p}). If an additional register of (N_{p}) ancillae is available, up to (N_{p}) swaps can be performed in parallel, reducing circuit depth dramatically. The fermionic sign arising from an odd number of exchanges is corrected by applying single‑qubit Z gates to the first (N_{T}) ancilla qubits; each Z adds a phase of (-1) when a projectile particle is swapped into a target slot.

3. Uncomputation of the ancilla – After all swaps, the ancilla register remains entangled with the particle registers. A simple uncomputation step consisting of (N_{T}+N_{p}) CNOT (or multi‑controlled NOT) gates disentangles the ancilla, returning it to (|0\rangle^{\otimes (N_{T}+N_{p})}). No inverse state‑preparation circuit for the target or projectile is required, because the phase correction has already been applied.

The algorithm’s resource count is therefore:

• Qubits: (N_{T}+N_{p}) particle registers + (N_{T}+N_{p}) ancilla qubits (plus optional extra ancillae for parallel swaps).
• Gate count: (O(N_{T}N_{p})) controlled‑swap operations, (O(N_{T}+N_{p})) Z gates for sign correction, and (O(N_{T}+N_{p})) CNOTs for uncomputation.
• Depth: Linear in (N_{T}N_{p}) in the worst case, but can be reduced to (O(N_{T}N_{p}/N_{p}) = O(N_{T})) when parallelism is exploited.

The paper also discusses the physical relevance: the target and projectile are initially placed far apart on a lattice, allowing a simple qubit (the most significant position qubit) to label whether a particle belongs to the target (|0⟩) or projectile (|1⟩). This labeling ensures that the internal structure of each subsystem remains untouched during antisymmetrization, which is crucial for realistic reaction simulations where the two nuclei have distinct internal excitations.

Figures illustrate the circuit for the case of two particles per subsystem (four total particles) and show how the Dicke ancilla selects the three required exchange channels. Additional examples with three particles per subsystem demonstrate the scaling of required swaps (e.g., eight swaps for a 3‑target/2‑projectile system). The paper emphasizes that although the algorithm does not explicitly generate higher‑order (k‑particle) permutations, the superposition of all one‑particle exchanges combined with the already antisymmetric initial states guarantees full antisymmetry of the final wavefunction.

In the supplemental material, the author provides explicit constructions for larger systems and discusses practical considerations such as fault‑tolerant implementation of multi‑controlled NOT gates, which recent work shows can be performed efficiently on surface‑code architectures. The overall conclusion is that the Dicke‑state‑mediated, single‑particle‑swap approach offers a deterministic, low‑depth, and hardware‑friendly pathway to prepare fully antisymmetric fermionic states for first‑quantized quantum simulations of nuclear reactions, thereby extending the applicability of quantum algorithms from few‑body problems to more realistic many‑nucleon scattering scenarios.