Linear Chain QAOA

• Linear Chain QAOA is a set of techniques that impose a 1D structure on cost Hamiltonians, parameter schedules, and hardware layouts to simplify circuit design and optimization.
• The approach reveals that even with reduced dimensionality, shallow QAOA on linear cost Hamiltonians can require exponential sampling time despite classical linear-time solvability.
• Hardware and parameter transfer benefits emerge from linear-chain treatments, as seen in reductions from 2p to four free parameters and improved compilation with linear nearest-neighbor architectures.

Searching arXiv for the topic and cited papers to ground the article in current literature. Linear Chain QAOA denotes several closely related uses of linear structure within the Quantum Approximate Optimization Algorithm. In one sense, it refers to QAOA applied to a line of qubits with a purely local linear cost Hamiltonian $H_P=\sum_i a_i Z_i$, where the problem decomposes into independent single-qubit rotations and yet fixed-depth QAOA can require exponential sampling time to obtain the exact optimum (Chicano et al., 9 May 2025). In a second sense, it refers to linearly constrained angle schedules across layer index, where $\gamma_l$ and $\beta_l$ are restricted to linear functions of $l/p$, reducing the parameter space from $2p$ variables to four and enabling parameter transfer across instances (Sakai et al., 2024, Sakai et al., 17 Apr 2025). In a third sense, it refers to hardware- or ansatz-level restriction to a linear nearest-neighbor chain, including compilation to LNN architectures and depth-independent MaxCut ansätze built on a single long path in the problem graph (Zhu et al., 2024, Wang et al., 22 Sep 2025). The term therefore spans problem Hamiltonians, parameter schedules, mixer topologies, and hardware layouts, but in all cases the defining feature is that a one-dimensional linear structure is imposed on an otherwise more general QAOA design.

1. Linear-chain meanings in the QAOA literature

The broad QAOA setting is the standard layered variational state

$$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$

with a cost Hamiltonian $C$ and mixer Hamiltonian $H_{\mathrm{mix}}=\sum_j X_j$ in the canonical construction (Sakai et al., 17 Apr 2025, Sakai et al., 2024). Within this general framework, “linear chain” appears in at least four distinct but related ways.

First, a linear chain may describe the problem Hamiltonian itself. The paper “The Quantum Approximate Optimization Algorithm Can Require Exponential Time to Optimize Linear Functions” studies linear Ising Hamiltonians

$$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$

or equivalently $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$, which on a line of qubits is a trivial one-dimensional instance with only on-site fields and no couplings (Chicano et al., 9 May 2025).

Second, a linear chain may describe a schedule in layer index. Two papers on simplified QAOA parameterization impose

$\gamma_l$0

so the angles lie on straight lines as depth increases (Sakai et al., 2024, Sakai et al., 17 Apr 2025). This is explicitly described as a linear dependence on layer index and as an annealing-like trajectory.

Third, a linear chain may describe the hardware graph. The compiler paper “Coqa: Blazing Fast Compiler Optimizations for QAOA” treats the linear nearest-neighbor architecture as a path

$\gamma_l$1

and develops QAOA-specific routing and SWAP reduction for such layouts (Zhu et al., 2024).

Fourth, a linear chain may describe a restricted entangling ansatz. “A Depth-Independent Linear Chain Ansatz for Large-Scale Quantum Approximate Optimization” proposes LC-QAOA, where a single long path is extracted from a MaxCut graph and entangling gates are placed only along that path in a brick-wall pattern, yielding a depth per QAOA layer that is independent of the number of vertices $\gamma_l$2 (Wang et al., 22 Sep 2025).

These usages are related by a common tradeoff. Linearization reduces dimensionality, routing complexity, or circuit depth, but it can either improve practical deployability or reduce expressivity, depending on which aspect of QAOA is linearized.

2. Linear cost Hamiltonians on a qubit line

For the linear-Ising setting, the optimization problem is

$\gamma_l$3

with $\gamma_l$4, and the paper restricts to $\gamma_l$5 so that the optimal spin assignment is $\gamma_l$6 for all $\gamma_l$7 (Chicano et al., 9 May 2025). In computational-basis language,

$\gamma_l$8

and the optimal bitstring is $\gamma_l$9 because $\beta_l$0 and $\beta_l$1 (Chicano et al., 9 May 2025).

With the standard mixer

$\beta_l$2

the depth-$\beta_l$3 state factorizes completely because both the cost and mixer unitaries decompose as tensor products of one-qubit rotations (Chicano et al., 9 May 2025). The resulting state is

$\beta_l$4

There is no entanglement at all; each qubit evolves independently under a sequence of $\beta_l$5- and $\beta_l$6-rotations determined by the shared parameters $\beta_l$7 and its local coefficient $\beta_l$8 (Chicano et al., 9 May 2025).

The probability of observing the optimum $\beta_l$9 is therefore

$l/p$0

The runtime model adopted in the paper replaces classical optimization by an oracle returning optimal parameters and defines runtime as the expected number of measurements needed to observe the global optimum,

$l/p$1

so any exponential decay in $l/p$2 directly yields exponential sampling time (Chicano et al., 9 May 2025).

The main theorem states that if $l/p$3 is constant independent of $l/p$4 and there exists a finite coefficient vector $l/p$5 for which $l/p$6 for all $l/p$7, then a family of repeated-pattern instances can be constructed on which QAOA runtime grows exponentially with $l/p$8 (Chicano et al., 9 May 2025). The construction repeats a base pattern $l/p$9 into

$2p$0

so that

$2p$1

Since $2p$2, the runtime obeys

$2p$3

which is exponential whenever the base is greater than $2p$4 (Chicano et al., 9 May 2025).

The paper proves explicit witnesses for small depth. For $2p$5, the two-variable instance $2p$6 satisfies

$2p$7

for all parameters, and the exact maximum is approximately $2p$8 (Chicano et al., 9 May 2025). For $2p$9, the three-variable instance $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$0 also satisfies $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$1 for all parameters (Chicano et al., 9 May 2025). The conjecture is that for each depth $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$2, there exists a coefficient vector with $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$3 distinct numbers such that perfect success probability is impossible at that depth, and that runtime is linear only if $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$4 (Chicano et al., 9 May 2025).

This result is striking precisely because the underlying instance is so simple. Classically, linear functions are solved in $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$5 time by reading off signs of coefficients, yet shallow QAOA with the standard $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$6-mixer can require exponential time even on these diagonal, local, unentangled one-dimensional instances (Chicano et al., 9 May 2025). A plausible implication is that locality and absence of entanglement do not by themselves guarantee efficient shallow-QAOA optimization.

3. Linear schedules across depth

A separate line of work uses “linear chain” to mean a linear trajectory of QAOA angles across layer index rather than a linear problem Hamiltonian. In this parameterization,

$$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$7

for $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$8, so the $$\ket{\boldsymbol{\gamma},\boldsymbol{\beta}} = e^{-i\beta_{p-1} H_{\mathrm{mix}}} e^{-i\gamma_{p-1} C} \cdots e^{-i\beta_{0} H_{\mathrm{mix}}} e^{-i\gamma_{0} C} \ket{+}^{\otimes n},$$9-parameter landscape is restricted to a four-dimensional manifold (Sakai et al., 2024, Sakai et al., 17 Apr 2025). Increasing depth refines the discretization of a straight ramp rather than introducing new free degrees of freedom (Sakai et al., 17 Apr 2025).

The motivation is explicitly annealing-like. Since QAOA approaches a trotterized adiabatic evolution in the large-$C$0 limit, a linear ramp is a discrete analogue of a simple annealing schedule in which the mixer is turned down while the cost term is turned up (Sakai et al., 2024, Sakai et al., 17 Apr 2025). The papers further argue that previously known parameter-setting strategies such as INTERP and FOURIER often produce optimal angles that are smooth and approximately linear in layer index (Sakai et al., 17 Apr 2025).

This linear parameterization is not merely a heuristic initialization. In both “Linearly simplified QAOA parameters and transferability” and “Transferring linearly fixed QAOA angles: performance and real device results,” the linear constraint is kept throughout optimization, and the resulting four parameters are then transferred across instances (Sakai et al., 2024, Sakai et al., 17 Apr 2025). The transfer protocol optimizes one source instance, fixes the four scalar coefficients, and then applies the resulting schedule directly to target instances without per-instance classical optimization (Sakai et al., 17 Apr 2025).

A representative optimized schedule reported for a 16-qubit random Ising instance at $C$1 is

$C$2

obtained by Bayesian optimization on the source instance (Sakai et al., 2024, Sakai et al., 17 Apr 2025). A manually chosen rough schedule also appears: $C$3 used to illustrate that even an unoptimized linear ramp can become useful when the Hamiltonian is appropriately normalized (Sakai et al., 17 Apr 2025).

These works report that the cost landscapes in the reduced four-parameter space exhibit recurring basin structure across random Ising instances, with similar valley locations persisting across changes in qubit number and edge density (Sakai et al., 2024, Sakai et al., 17 Apr 2025). The later paper extends the analysis to IBM’s Eagle hardware and states that the same global basin structure is visible on ibm_brisbane, though broadened by noise (Sakai et al., 17 Apr 2025). This supports the claim that transferability depends primarily on energy scale, because multiplying the Hamiltonian by a factor $C$4 rescales the optimal $C$5 values by $C$6 (Sakai et al., 17 Apr 2025).

For random Ising instances on 16 qubits at $C$7, the later paper reports at $C$8 the following approximation ratios $C$9: Standard $H_{\mathrm{mix}}=\sum_j X_j$0, INTERP $H_{\mathrm{mix}}=\sum_j X_j$1, FOURIER $H_{\mathrm{mix}}=\sum_j X_j$2, and LINXFER $H_{\mathrm{mix}}=\sum_j X_j$3 (Sakai et al., 17 Apr 2025). The corresponding optimization times are Standard $H_{\mathrm{mix}}=\sum_j X_j$4 s, INTERP $H_{\mathrm{mix}}=\sum_j X_j$5 s, FOURIER $H_{\mathrm{mix}}=\sum_j X_j$6 s, and LINXFER $H_{\mathrm{mix}}=\sum_j X_j$7 s per instance after a one-time pretraining cost of $H_{\mathrm{mix}}=\sum_j X_j$8 s (Sakai et al., 17 Apr 2025). The earlier transferability paper reports strong cross-instance and cross-problem performance, including an average $H_{\mathrm{mix}}=\sum_j X_j$9 when parameters trained on a random Ising instance are transferred to Max-Cut instances (Sakai et al., 2024).

The significance of the linear schedule viewpoint is therefore practical rather than asymptotic. It does not assert superior expressivity. Rather, it exploits observed smoothness of good QAOA angles to reduce optimization overhead from a $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$0-dimensional problem to a four-dimensional one and to enable pretraining and parameter reuse (Sakai et al., 2024, Sakai et al., 17 Apr 2025). This suggests that for many NISQ-relevant tasks, the effective control manifold may be much lower-dimensional than the formal $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$1-parameter ansatz.

4. Linear nearest-neighbor architectures and compilation

On hardware, “linear chain QAOA” commonly refers to implementation on a linear nearest-neighbor architecture, where qubits are arranged in a line and direct interactions are allowed only between adjacent sites (Zhu et al., 2024). In that setting, the central problem is compilation of QAOA cost layers, whose $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$2-derived two-qubit gates may not align with hardware connectivity.

The compiler “Coqa” exploits two structural properties of QAOA circuits. First, in graph-based QAOA such as MaxCut, all two-qubit gates within a cost layer commute because they originate from a sum of mutually commuting $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$3 terms (Zhu et al., 2024). Second, if the hardware is treated as a linear chain, or as a linearized heavy-hex graph with dangling qubits, then a global SWAP pattern can be designed so that required pairs become adjacent in a predictable order (Zhu et al., 2024).

Coqa adapts a routing pattern derived from QFT compilation on a linearized heavy-hex topology. Qubits sweep along the line and interact whenever they become neighbors; because QAOA cost-layer gates commute, an interaction can be executed immediately rather than at a fixed scheduled time (Zhu et al., 2024). The compiler further uses the weights of the problem Hamiltonian to prune unnecessary routing: if bringing two qubits together would only realize a zero-weight or nonexistent interaction, the corresponding SWAPs can be skipped (Zhu et al., 2024).

For the resulting mapping pattern, the paper gives a linear upper bound $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$4 on mapping complexity and states that for every 5 qubits at most 25 steps are required, so the total time complexity is linear in $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$5 (Zhu et al., 2024). Empirically, it reports an average $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$6 reduction in gate count and a $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$7 acceleration in compilation time across benchmarks (Zhu et al., 2024). For example, compilation times on 65, 125, 515, and 1025 qubits are reported as $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$8, $$H_P(s)=\sum_{\ell=1}^n a_\ell s_\ell,\qquad s_\ell\in\{-1,1\},$$9, $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$0, and $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$1 s for Coqa, whereas QAIM requires $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$2, $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$3, more than 5 hours, and more than 5 hours, respectively (Zhu et al., 2024).

These results show that a linear chain is not only a physical restriction but also a compiler design principle. QAOA’s commuting cost layers permit routing strategies that are more structured than generic quantum circuit compilation, and on LNN-style hardware this can substantially reduce both SWAP overhead and classical compile time (Zhu et al., 2024). A plausible implication is that for hardware-constrained QAOA, the relevant notion of efficiency may depend as much on compiler exploitation of commuting structure as on the abstract gate count of the logical ansatz.

5. Depth-independent linear-chain ansätze for MaxCut

The most literal use of the phrase appears in “A Depth-Independent Linear Chain Ansatz for Large-Scale Quantum Approximate Optimization,” which introduces LC-QAOA as a variant of QAOA for MaxCut on non-hardware-native graphs (Wang et al., 22 Sep 2025). Instead of encoding all graph edges in the cost layer, LC-QAOA first finds a long path in the problem graph by a greedy depth-first search, then keeps only the edges of this path and maps them to a hardware-native linear chain of qubits (Wang et al., 22 Sep 2025).

If the path is $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$4, the restricted cost Hamiltonian takes the form

$H_P=\sum_{\ell=1}^n a_\ell Z_\ell$5

and the corresponding entangling gates are implemented as $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$6 (Wang et al., 22 Sep 2025). Because the path is one-dimensional, the chain edges can be partitioned into two disjoint sets, such as $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$7 and $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$8, producing a brick-wall schedule of exactly two parallel two-qubit sublayers per QAOA layer (Wang et al., 22 Sep 2025). Mixer layers remain the standard parallel $H_P=\sum_{\ell=1}^n a_\ell Z_\ell$9 rotations on all qubits (Wang et al., 22 Sep 2025).

The resulting LC-QAOA state is

$\gamma_l$00

with $\gamma_l$01 as usual (Wang et al., 22 Sep 2025). For fixed $\gamma_l$02, the cost layer requires exactly two time steps of two-qubit gates and one time step of single-qubit rotations, so the logical depth per QAOA layer is independent of the number of vertices $\gamma_l$03 (Wang et al., 22 Sep 2025).

This restriction changes scaling dramatically. Standard QAOA for MaxCut on bounded-degree random graphs requires $\gamma_l$04 logical entangling gates and incurs large SWAP overhead on heavy-hex hardware, whereas LC-QAOA uses only the chain edges, so two-qubit gate count scales linearly in $\gamma_l$05 and execution time remains essentially constant in $\gamma_l$06 (Wang et al., 22 Sep 2025). The paper reports that on ibm_rensselaer standard QAOA$\gamma_l$07 for 100-vertex random 3-regular instances has execution time around $\gamma_l$08, close to the relaxation time $\gamma_l$09, while LC-QAOA avoids this depth explosion by staying hardware-native (Wang et al., 22 Sep 2025).

The empirical results are correspondingly hardware-oriented. On ibm_kingston for a 100-vertex random 3-regular graph, standard QAOA$\gamma_l$10 achieves mean approximation ratio $\gamma_l$11, while LC-QAOA$\gamma_l$12 achieves mean approximation ratio $\gamma_l$13 (Wang et al., 22 Sep 2025). Across multiple 100-vertex random 3-regular instances, LC-QAOA$\gamma_l$14 yields mean approximation ratios around $\gamma_l$15–$\gamma_l$16, LC-QAOA$\gamma_l$17 around $\gamma_l$18–$\gamma_l$19, and LC-QAOA$\gamma_l$20 on a 100-vertex instance reaches mean approximation ratio $\gamma_l$21 with best approximation ratio $\gamma_l$22, all without error mitigation or post-processing (Wang et al., 22 Sep 2025). The abstract highlights the approximation ratio of $\gamma_l$23 without post-processing on non-hardware-native random regular MaxCut instances with 100 vertices on a 100-qubit processor (Wang et al., 22 Sep 2025).

The paper also studies a chain-percentage parameter, defined as the fraction of vertices included in the linear chain, and reports that mean approximation ratio decreases gradually as chain percentage decreases, reaching random-guess behavior at $\gamma_l$24 (Wang et al., 22 Sep 2025). This indicates that the ansatz remains meaningful even when the extracted path is not Hamiltonian, but its effectiveness tracks how much of the problem graph is represented in the chain (Wang et al., 22 Sep 2025).

LC-QAOA thus formalizes a particular hardware-efficient compromise: encode only a single path rather than the full graph, accept reduced expressivity, and use the depth savings to operate at larger $\gamma_l$25 and higher $\gamma_l$26 on real devices (Wang et al., 22 Sep 2025). This suggests that in NISQ settings, ansatz restriction can outperform faithful compilation of the full logical problem.

6. Linear-chain mixers, convergence, and constrained variants

The literature also contains several results relevant to linear-chain QAOA from the perspective of mixer topology and convergence. For unconstrained and constrained QAOA in general, “Elementary Proof of QAOA Convergence” proves that if the phase separator is diagonal and the mixer or mixing family is irreducible and non-negative on the feasible subspace, then for every $\gamma_l$27 there exists finite depth $\gamma_l$28 such that the QAOA state is within $\gamma_l$29 of the optimal solution subspace (Binkowski et al., 2023). The proof is topology-agnostic at the logical-operator level and therefore applies equally to one-dimensional nearest-neighbor architectures provided the chosen local mixers satisfy the mixing-family conditions (Binkowski et al., 2023).

A particularly explicit one-dimensional analysis appears in “Optimizing QAOA: Success Probability and Runtime Dependence on Circuit Depth,” which studies state transfer on an open chain of $\gamma_l$30 qubits in the zero- and single-excitation subspace using the XY Hamiltonian

$\gamma_l$31

and a cost Hamiltonian $\gamma_l$32 marking the last site (Niu et al., 2019). The depth-$\gamma_l$33 QAOA circuit alternates $\gamma_l$34 and $\gamma_l$35, and in an analytically tractable Grover-like ansatz with fixed $\gamma_l$36 and $\gamma_l$37, the paper derives success-probability scaling that is quadratic in $\gamma_l$38 at low depth and yields a Grover-like $\gamma_l$39 depth to constant success probability (Niu et al., 2019). It further reports numerical evidence up to $\gamma_l$40 that optimized QAOA on the chain reaches high-fidelity transfer and that controllability improves sharply beyond a depth threshold (Niu et al., 2019).

Constrained linear-chain design is treated from another angle in “Convergence guarantee for linearly-constrained combinatorial optimization with a quantum alternating operator ansatz.” That paper studies QAOA$\gamma_l$41 for problems with a single linear constraint whose coefficients are sequential integers $\gamma_l$42, and builds mixing Hamiltonians from asymmetric merge operators $\gamma_l$43 satisfying $\gamma_l$44 (Goldstein-Gelb et al., 2024). The minimal mixing family $\gamma_l$45 consists of row-wise swaps and merge moves that effectively step through the coefficient ladder $\gamma_l$46, and the main theorem shows that any mixing family satisfying $\gamma_l$47 is a valid mixing family in the sense needed for adiabatic-limit convergence (Goldstein-Gelb et al., 2024). This is not a spatial linear chain of qubits, but it is a chain structure in coefficient space that induces a connected feasible-state graph and a provably convergent constrained QAOA$\gamma_l$48 ansatz (Goldstein-Gelb et al., 2024).

These results indicate that linear-chain constructions enter QAOA not only through hardware simplification but through precise algebraic and graph-theoretic control of the reachable subspace. Inference from the combined literature suggests that one-dimensionality can either simplify analysis, as in XY-chain controllability, or serve as a structured restriction that makes convergence arguments tractable, as in sequential-coefficient QAOA$\gamma_l$49.

7. Limitations, tensions, and open directions

The literature on linear-chain QAOA presents a notable tension. On the one hand, linearization often improves practical deployability. Linear schedules reduce optimization from $\gamma_l$50 variables to four and make parameter transfer viable across instances and even across hardware (Sakai et al., 2024, Sakai et al., 17 Apr 2025). Linear nearest-neighbor compilation exploits commuting cost layers to cut routing overhead (Zhu et al., 2024). Path-restricted LC-QAOA keeps depth independent of problem size and has demonstrated large-scale MaxCut performance on heavy-hex processors (Wang et al., 22 Sep 2025).

On the other hand, linearization can severely restrict expressivity. The strongest negative result is that even the simplest linear cost Hamiltonians on a qubit line can force exponential sampling time for constant-depth QAOA with the usual $\gamma_l$51-mixer (Chicano et al., 9 May 2025). The Lie-algebraic analysis of XY mixers sharpens the same theme in a different regime: linear-chain XY or XY+$\gamma_l$52 topologies have polynomial-size DLAs and are therefore trainable, but as soon as $\gamma_l$53 interactions are added the DLA becomes exponential, so improved expressivity comes with poor trainability and likely barren plateaus (Kordonowy et al., 23 May 2025).

A recent extension connects these strands to counterdiabatic control. “Pauli-Sparse regularised Counterdiabatic Shortcuts for Linear-Ramp QAOA” considers linear-ramp QAOA based on

$\gamma_l$54

and constructs Pauli-sparse regularized adiabatic gauge potentials by solving

$\gamma_l$55

in truncated Pauli coordinates (Cipolla et al., 26 Jun 2026). The regularization parameter $\gamma_l$56 acts as an energy-resolution scale, suppressing transitions below $\gamma_l$57 while preserving larger-gap transitions, and numerical experiments on Ferromagnetic Chain and perturbed FC–MaxCut/MarketSplit instances show improved approximation ratios over uncorrected linear-ramp QAOA, especially where the linear ramp remains far from the optimum (Cipolla et al., 26 Jun 2026). This suggests that some of the expressivity lost by rigid linear schedules may be recovered through sparse counterdiabatic corrections without returning to a full $\gamma_l$58-parameter search.

A further open issue is terminology itself. The phrase “linear chain QAOA” is used in incompatible ways across papers: as a layerwise linear schedule (Sakai et al., 2024, Sakai et al., 17 Apr 2025), as a path-restricted hardware-native ansatz (Wang et al., 22 Sep 2025), as QAOA on purely local linear fields (Chicano et al., 9 May 2025), and as XY-mixer QAOA on path topologies (Kordonowy et al., 23 May 2025, Niu et al., 2019). These are not equivalent notions. Some simplify the control schedule, some simplify the cost Hamiltonian, some simplify the hardware graph, and some simplify the Lie algebra. A precise use of the term therefore requires specifying which linear object is intended: coefficients, layers, topology, or entangling subgraph.

Taken together, the literature shows that linear-chain QAOA is less a single algorithm than a family of structured QAOA reductions. Their common purpose is to exploit one-dimensional organization—of fields, parameters, couplings, or hardware—to obtain tractable optimization, efficient compilation, or shallow circuits. Their common limitation is that the same structure can impose nontrivial expressivity barriers.