Multi-Parallelized Quantum LSTM

• The paper introduces MP-QLSTM as a hybrid recurrent model that replaces classical affine maps with parallel variational quantum circuits to compute LSTM gates.
• It details two implementations—distributed/modular and dimension-wise—that improve forecasting performance by partitioning quantum circuits across QPUs or state dimensions.
• The work underscores practical benefits like faster convergence and improved accuracy, while noting challenges such as noise, synchronization, and hardware constraints.

Searching arXiv for the cited papers and closely related work on QLSTM/MP-QLSTM. Multi-Parallelized Quantum Long Short-Term Memory (MP-QLSTM) denotes a class of hybrid quantum-classical recurrent architectures that extend Quantum Long Short-Term Memory (QLSTM) by evaluating multiple variational quantum circuits (VQCs) in parallel within an LSTM-type cell. In the current arXiv literature represented here, the name appears explicitly for a one-VQC-per-dimension design for high-dimensional time-series forecasting (Takagi et al., 15 Jul 2025), and it also maps directly to a distributed/modular QLSTM in which each gate VQC is partitioned across multiple quantum processing units (QPUs) and aggregated classically (Chen et al., 18 Mar 2025). Both formulations descend from QLSTM, where classical affine maps in LSTM gates are replaced by parameterized quantum circuits whose measurements produce real-valued gate vectors (Chen et al., 2020).

1. Emergence and nomenclature

The immediate antecedent of MP-QLSTM is QLSTM, introduced as a hybrid quantum-classical model in which six VQC blocks are embedded into an LSTM cell. In that design, four VQCs generate the forget, input, cell-candidate, and output gate vectors from the concatenated recurrent input, while two further VQCs transform the gated cell activation into the hidden state and output. The reported implementation used six 4-qubit VQCs of variational depth $2$, with $146$ trainable parameters, and compared against a classical LSTM baseline with hidden size $5$ and $166$ total parameters (Chen et al., 2020).

Subsequent work developed two distinct parallelization lineages. One lineage introduced a distributed QLSTM for modular quantum computers, in which each gate is implemented by an ensemble of smaller VQCs executed concurrently across multiple QPUs, with classical aggregation at every time step. The source explicitly states that the term “Multi-Parallelized QLSTM (MP-QLSTM)” is not used in that paper, but that it maps directly to the distributed/modular QLSTM (Chen et al., 18 Mar 2025). A second lineage used the term “multi-parallelized quantum long short-term memory” explicitly for a forecasting model that assigns one VQC to each cell-state dimension and measures all qubits in each VQC, thereby increasing representation capacity relative to earlier QLSTM variants (Takagi et al., 15 Jul 2025).

A related, but conceptually different, development interpreted entangling power and disentangling power of unitaries as memory-retention and forgetting mechanisms in quantum recurrent architectures. That work models a QLSTM cell through a pair of trainable unitary blocks $U_{\mathrm{en}}$ and $U_{\mathrm{dis}}$, with the hidden state residing in ancilla qubits. It does not define MP-QLSTM explicitly, but it provides a recurrent quantum-memory interpretation that is relevant to the broader QLSTM family (Daskin, 10 May 2025).

2. Recurrent structure and mathematical formulation

At the classical level, the underlying recurrence remains the standard LSTM update. With $v_t = [h_{t-1}; x_t]$, the canonical equations are

$$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$

$$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$

QLSTM replaces the affine maps $W_\alpha v_t + b_\alpha$ by quantum circuits: $146$0

$146$1

The quantum computation is expressed as

$146$2

$146$3

with the gate vector obtained by stacking measurement outputs across measurement heads or qubits (Chen et al., 18 Mar 2025).

Across the literature represented here, the “multi-parallelized” aspect is instantiated in two structurally different ways:

Variant	Parallel unit	Gate assembly
Distributed/modular MP-QLSTM	$146$4 sub-VQCs per gate across QPUs	Concatenate submodule outputs, then apply $146$5 or $146$6
Dimension-wise MP-QLSTM	$146$7 VQCs per gate, one per state dimension	Concatenate $146$8 scalar outputs into the gate vector

In the distributed/modular form, the recurrent input is partitioned as

$146$9

and each sub-vector feeds a separate subcircuit. The global unitary is conceptualized as

$5$0

with no inter-module quantum entanglement. Gate aggregation is then

$5$1

and analogously for $5$2, $5$3, and $5$4 (Chen et al., 18 Mar 2025).

In the explicit MP-QLSTM of high-dimensional forecasting, the recurrent input is written as

$5$5

For each gate $5$6 and each dimension $5$7,

$5$8

and the gates are assembled as

$5$9

$166$0

followed by the standard updates

$166$1

The paper states that setting $166$2 in the VQC-input equation and replacing each VQC with an identity operator reduces MP-QLSTM to a classical LSTM (Takagi et al., 15 Jul 2025).

3. Encoding, circuit ansätze, and readout strategies

Input encoding is not uniform across QLSTM variants. The original QLSTM initializes $166$3 qubits in $166$4, applies Hadamard gates to obtain the unbiased superposition $166$5, and then uses $166$6 and $166$7 rotations with

$166$8

Its variational layer uses a cyclic CNOT entangling pattern and trainable single-qubit rotations $166$9, with Pauli-$U_{\mathrm{en}}$0 expectation values as readout (Chen et al., 2020).

The distributed/modular QLSTM emphasizes angle-based local encoding through an encoding unitary $U_{\mathrm{en}}$1, with examples such as $U_{\mathrm{en}}$2 and $U_{\mathrm{en}}$3 rotations whose angles are functions of components of $U_{\mathrm{en}}$4. Amplitude encoding is discussed conceptually but is not used, because it would require exponentially many basis amplitudes. After encoding, each gate-specific circuit applies a parameterized ansatz composed of layers of single-qubit rotations and entangling gates such as CNOT, and measures chosen observables $U_{\mathrm{en}}$5 to produce a real vector output (Chen et al., 18 Mar 2025).

The explicit MP-QLSTM for high-dimensional forecasting uses multiple linear layers to generate rotation angles. For each gate and each state dimension, $U_{\mathrm{en}}$6 linear layers map $U_{\mathrm{en}}$7 to the parameters of $U_{\mathrm{en}}$8, $U_{\mathrm{en}}$9, and $U_{\mathrm{dis}}$0 on $U_{\mathrm{dis}}$1 qubits. Rotations are interleaved with entangling CNOTs, rather than being placed only after entanglers. In the measurement layer, all qubits of each VQC are measured with Pauli-$U_{\mathrm{dis}}$2 operators. The paper identifies full-qubit measurement as a central design choice, contrasting it with earlier QLSTM implementations that measure only a subset of qubits to match hidden-state dimensionality (Takagi et al., 15 Jul 2025).

A distinct encoding philosophy appears in the entangling/disentangling formulation. There, the classical input is projected into the system Hilbert space by an affine map followed by amplitude normalization,

$U_{\mathrm{dis}}$3

while the hidden state is represented in an ancilla register. The joint state

$U_{\mathrm{dis}}$4

is evolved by

$U_{\mathrm{dis}}$5

Here, $U_{\mathrm{dis}}$6 is associated with information retention through entanglement, and $U_{\mathrm{dis}}$7 with forgetting through disentanglement (Daskin, 10 May 2025).

4. Training, orchestration, and computational scaling

Training is hybrid quantum-classical. Quantum parameters are differentiated by the parameter-shift rule,

$U_{\mathrm{dis}}$8

A generic sequence loss for the distributed/modular formulation is

$U_{\mathrm{dis}}$9

where $v_t = [h_{t-1}; x_t]$0 is the model prediction and $v_t = [h_{t-1}; x_t]$1 is ground truth (Chen et al., 18 Mar 2025).

In the original QLSTM experiments, optimization used RMSprop with learning rate $v_t = [h_{t-1}; x_t]$2, smoothing constant $v_t = [h_{t-1}; x_t]$3, and $v_t = [h_{t-1}; x_t]$4, with all training and loss evaluation implemented in PyTorch. The paper emphasizes that training on actual NISQ hardware is a “significant challenge” because the number of circuit evaluations per epoch grows at least as $v_t = [h_{t-1}; x_t]$5, where $v_t = [h_{t-1}; x_t]$6 is the number of parameters, $v_t = [h_{t-1}; x_t]$7 is the number of circuits per cell, and $v_t = [h_{t-1}; x_t]$8 is dataset size. For that work, $v_t = [h_{t-1}; x_t]$9, $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$0, and $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$1 depending on the experiment. By contrast, inference with pre-trained parameters is described as scaling as $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$2 (Chen et al., 2020).

The distributed/modular formulation adds an explicit orchestration layer. A classical controller partitions $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$3, dispatches jobs to QPUs, collects expectation values, concatenates partial vectors, applies $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$4 or $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$5, updates $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$6 and $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$7, computes loss and gradients, applies parameter-shift for quantum parameters, and performs optimizer steps. Execution is synchronous at each time step: all $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$8 subcircuits complete before the state update. Each sub-VQC is assigned a shot budget $$i_t = \sigma(W_i v_t + b_i),\qquad f_t = \sigma(W_f v_t + b_f),\qquad o_t = \sigma(W_o v_t + b_o),$$9, and gradients across modules are aggregated classically. The paper notes that data parallelism is compatible at batching or micro-batching level, whereas pipeline parallelism is not explicitly employed because time-step dependencies require $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$0 and $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$1 before the next step can be evaluated (Chen et al., 18 Mar 2025).

The explicit MP-QLSTM for high-dimensional forecasting was implemented with Qiskit and PyTorch and trained on a simulator. On the pressure dataset, the reported hyperparameters were Adam, learning rate $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$2, batch size $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$3, hidden dimension $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$4, number of linear layers $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$5, and $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$6 qubits per VQC. The paper does not explicitly detail shots or gradient methods such as parameter-shift in that setting (Takagi et al., 15 Jul 2025). In the entangling/disentangling framework, end-to-end backpropagation is used over the hybrid pipeline, with gradients estimated using the parameter-shift rule as implemented by the quantum machine learning toolkit referenced there (Daskin, 10 May 2025).

5. Benchmarks, empirical results, and application domains

The empirical literature spans temporal regression benchmarks, nonlinear autoregression, non-Markovian dynamics, cavity-QED observables, and high-dimensional spatial forecasting. The reported results show that QLSTM-type models can converge faster, exhibit more stable loss descent, or attain lower test loss than classical recurrent baselines in several settings, although superiority is not universal across all tasks (Chen et al., 18 Mar 2025, Chen et al., 2020, Takagi et al., 15 Jul 2025).

Setting	Representative quantitative result	Reported significance
Damped oscillator / pendulum, distributed QLSTM	Distributed QLSTM: $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$7, epochs $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$8; Centric QLSTM (5 qubits): $$\tilde{c}_t = \tanh(W_c v_t + b_c),\qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t,\qquad h_t = o_t \odot \tanh(c_t).$$9, epochs $W_\alpha v_t + b_\alpha$0	Distributed model matched top monolithic performance with efficient convergence
NARMA-2, distributed QLSTM	Distributed QLSTM: $W_\alpha v_t + b_\alpha$1, epochs $W_\alpha v_t + b_\alpha$2; Centric QLSTM (4 qubits): $W_\alpha v_t + b_\alpha$3, epochs $W_\alpha v_t + b_\alpha$4	Distributed model was competitive, with rapid convergence
Pressure-sensitive-paint forecasting, MP-QLSTM	Test MSE: LSTM $W_\alpha v_t + b_\alpha$5, GRU $W_\alpha v_t + b_\alpha$6, L-QLSTM $W_\alpha v_t + b_\alpha$7, MP-QLSTM $W_\alpha v_t + b_\alpha$8, MP-QGRU $W_\alpha v_t + b_\alpha$9	MP-QLSTM and MP-QGRU were $146$00 lower than LSTM/GRU and $146$01 lower than L-QLSTM
Full-field reconstruction from five sensors	RMSPE: LSTM $146$02, MP-QLSTM $146$03	Reconstruction was accurate against independent semiconductor pressure sensor values
Solar power forecasting	MP-QLSTM: MAE $146$04 MW, MSE $146$05 $146$06	$146$07 better in MAE and $146$08 better in MSE than LSTM/GRU
Lorenz system with Gaussian noise, std $146$09	MAE: MP-QLSTM $146$10, LSTM $146$11; MSE: MP-QLSTM $146$12, LSTM $146$13	MP-QLSTM was more robust at higher noise
Original QLSTM, sine function, epoch 15	QLSTM train $146$14, test $146$15; LSTM train $146$16, test $146$17	QLSTM loss decreased more stably without spikes

The application scope also broadened substantially in the explicit MP-QLSTM work. There, forecasting is one stage in a pipeline for high-dimensional spatial data: truncated SVD/POD is used for reduced-order modeling, a digital annealer is used for optimal sensor placement, MP-QLSTM or MP-QGRU forecasts the selected sensor time series, and a learned decoder reconstructs the full spatial field. The main pressure-sensitive-paint dataset consists of $146$18 pressure maps over $146$19 time points, truncated to rank $146$20, with $146$21 sensors and forecast windows of length $146$22 (Takagi et al., 15 Jul 2025).

The original QLSTM study used a simpler one-step forecasting protocol: given the last $146$23 values in a time series, predict the next value, with training on the first $146$24 of the sequence and testing on the remaining $146$25, for up to $146$26 epochs. Across sine, damped harmonic oscillator, Bessel function $146$27, delayed quantum control, and population inversion $146$28 in cavity QED, QLSTM was reported to converge faster or fit more accurately than the classical LSTM with a similar number of parameters (Chen et al., 2020).

6. Constraints, misconceptions, and future directions

A recurring misconception is that “multi-parallelized” implies unconstrained parallel execution across the temporal axis. The literature does not support that interpretation. Because $146$29 is required to compute $146$30, recurrence imposes a sequential dependency across time steps. The distributed/modular design is therefore time-synchronous per step, and the original QLSTM analysis explicitly notes that parallelization across time steps is inherently limited by data dependency (Chen et al., 18 Mar 2025, Chen et al., 2020).

A second misconception is that MP-QLSTM is a purely quantum recurrent model. In all formulations summarized here, the recurrent state update, nonlinear activations, loss evaluation, and optimizer step are at least partly classical. Even in the entangling/disentangling formulation, the architecture is explicitly quantum-classical, and the measured scalar output is combined with classical training machinery (Daskin, 10 May 2025).

The distributed/modular literature also makes clear that current implementations do not employ inter-module quantum links such as SWAP networks or teleportation. Interaction is purely classical aggregation of expectation values. This lowers the hardware burden but constrains expressivity: cross-module correlations are captured only classically, and the absence of inter-module entanglement can limit what the modular factorization

$146$31

can represent. The same work identifies communication and synchronization overhead, shot variance, noise accumulation, barren plateaus in deeper ansätze, and load imbalance among modules as practical limitations (Chen et al., 18 Mar 2025).

For explicit MP-QLSTM in forecasting, a central limitation is that all quantum components were trained on simulators. Real-device noise, finite shots, and gradient-estimation overheads were not analyzed in detail, and performance may change under hardware execution. The authors also note that runtime scales linearly with hidden dimension $146$32 and sequence length, since LSTM requires $146$33 VQCs per time step and GRU requires $146$34 VQCs per step (Takagi et al., 15 Jul 2025).

The entangling/disentangling framework adds a conceptual limitation of a different kind: it argues that prior knowledge of the entangling power of unitaries can guide circuit design, yet it does not provide an explicit regularization term in the loss depending on $146$35 or $146$36. This suggests a future direction rather than a completed optimization prescription (Daskin, 10 May 2025).

Future work named explicitly across these papers includes better partitioning heuristics for balancing $146$37 and $146$38, adaptive shot allocation, error mitigation through readout calibration, zero-noise extrapolation, randomized compiling, hardware-aware transpilation, cross-module entanglement through photonic interconnects or teleportation, hybrid amplitude-angle encoding, data re-upload strategies, deeper VQCs, adaptive choices of $146$39, and eventual incorporation of logical qubits and fault-tolerant cross-module links as hardware matures (Chen et al., 18 Mar 2025, Takagi et al., 15 Jul 2025). Taken together, these directions indicate that MP-QLSTM is presently best understood as a family of modular and dimension-parallel quantum recurrent designs whose main differentiators are how they distribute VQCs, how they measure and aggregate quantum outputs, and how they trade expressivity against NISQ-era resource constraints.