Quantum Complexity Overview

• Quantum complexity is a study of the resources required for quantum state and operator processes. These resources can include the number of gates, circuit depth or gate count, and complexity classes, and depend on factors such as the gate set, locality constraints, and approximation tolerance. The principal models are quantum circuits, quantum Turing machines, and bounded-depth quantum circuits, with key classes including $BQP$ and $QMA$
• Quantum complexity has applications across various fields, including quantum algorithms, verification, Hamiltonian simulation, quantum error correction, many-body dynamics, and quantum field theory in holography. Within quantum computing, high complexity and saturation promote protocols based on deep-high-count quantum circuits. Potential examples include QUADER, TQC, PINES, CHSRS, GCRA

Quantum complexity is the study of the resources required to construct, simulate, verify, distinguish, or transform quantum states, operators, channels, and computational processes. The term does not denote a unique quantity: depending on the model, it may refer to a complexity class such as $BQP$ or $QMA$, the minimum gate count or circuit depth for synthesizing a unitary, a geometric distance on a unitary group, the difficulty of recognizing a state with a bounded circuit, a locality-sensitive transport cost, or the information required by an optimal predictive model. These notions depend on the gate set, locality constraints, approximation tolerance, reference state, allowed measurements, ancillary systems, and whether the dynamics are unitary, stochastic, or dissipative.

1. Computational complexity classes and quantum models

Quantum computational complexity is commonly formulated for promise problems rather than only ordinary languages. A promise problem is a pair

$A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$

where the two sets are disjoint subsets of binary strings; inputs outside their union are unrestricted. Quantum states are represented by density matrices, and physical operations by completely positive trace-preserving maps.

The principal computational models are quantum circuits, quantum Turing machines, and bounded-depth quantum circuits. Quantum circuits consist of acyclic networks of constant-size gates. A finite universal gate set can contain Toffoli, Hadamard, phase-shift, ancillary-$\lvert0\rangle$, and erasure gates. General circuits can be purified into unitary circuits by replacing ancillas with $\lvert0\rangle$ inputs and tracing out or ignoring designated output qubits. Universality means that an operation $\Phi$ can be approximated by a circuit $Q$ in diamond norm:

$\delta(\Phi,Q)<\varepsilon,$

with circuit size polynomial in $\log(1/\varepsilon)$ for fixed input and output dimensions (0804.3401).

The standard classical reference classes include $P$, $QMA$0, $QMA$1, $QMA$2, $QMA$3, $QMA$4, $QMA$5, $QMA$6, $QMA$7, $QMA$8, and $QMA$9. The equality

$A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$0

is a central classical benchmark. Bounded-error classes are robust under amplification: constant completeness and soundness gaps can generally be reduced to exponentially small error using polynomially many repetitions and majority vote.

BQP

$A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$1, bounded-error quantum polynomial time, consists of promise problems decided by polynomial-time generated quantum circuit families with bounded error. A circuit family $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$2 accepts yes-instances with probability at least $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$3 and no-instances with probability at most $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$4. The standard inclusion

$A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$5

follows because classical Boolean computation and random bits can be embedded into quantum circuits.

Factoring and discrete logarithm are prominent problems in $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$6 but not known to lie in $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$7, through Shor’s algorithms. This does not establish an unconditional separation between $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$8 and $A=(A_{\mathrm{yes}},A_{\mathrm{no}}),$9. Known containments include

$\lvert0\rangle$0

and

$\lvert0\rangle$1

where $\lvert0\rangle$2 is the unbounded-error quantum class. The paper also gives

$\lvert0\rangle$3

through a coherent subroutine construction. Oracle results provide relative separations, including oracles $\lvert0\rangle$4 for which $\lvert0\rangle$5, $\lvert0\rangle$6, and $\lvert0\rangle$7, but these do not imply corresponding unrelativized separations (0804.3401).

QMA and QCMA

$\lvert0\rangle$8 is the quantum analogue of $\lvert0\rangle$9: Merlin supplies a quantum witness and Arthur performs an efficient quantum verification. For a witness $\lvert0\rangle$0 and verifier $\lvert0\rangle$1, completeness requires

$\lvert0\rangle$2

whereas soundness requires

$\lvert0\rangle$3

The quantifier structure distinguishes $\lvert0\rangle$4 from $\lvert0\rangle$5. The established containments

$\lvert0\rangle$6

follow respectively from classical witnesses being special quantum states and from a verifier’s ability to ignore its witness.

The $\lvert0\rangle$7-local Hamiltonian problem is $\lvert0\rangle$8-complete under Karp reductions. Given

$\lvert0\rangle$9

the task is to distinguish whether some state has low energy from whether every state has high energy. This problem is the quantum counterpart of Cook–Levin and is connected to adiabatic quantum computation. Other $\Phi$0-related problems include consistency of local density matrices, the quantum clique problem, non-identity check for quantum circuits, and group non-membership.

$\Phi$1—also called $\Phi$2 in the cited survey—restricts Merlin to a classical witness while retaining quantum verification. Whether quantum witnesses are strictly more powerful remains open:

$\Phi$3

The class $\Phi$4 allows two unentangled quantum proofs. Although

$\Phi$5

the power of $\Phi$6 is poorly understood; the cited upper bound is

$\Phi$7

QIP

$\Phi$8 consists of polynomial-round interactions between a polynomial-time quantum verifier and an unbounded quantum prover. The low-round cases satisfy

$\Phi$9

Classical interactive proofs imply

$Q$0

while semidefinite-programming simulations give

$Q$1

A major parallelization theorem reduces polynomial-round protocols to three messages:

$Q$2

Quantum circuit distinguishability is $Q$3-complete. Given channels $Q$4 and $Q$5, the problem distinguishes diamond-norm distance at least $Q$6 from distance at most $Q$7. The need to consider entangled input states is essential to the diamond norm. Quantum statistical zero knowledge satisfies

$Q$8

and quantum state distinguishability is $Q$9-complete (0804.3401).

2. Circuit, state, and operator complexity

For a unitary transformation or pure state, conventional circuit complexity is the minimum number of elementary gates required to implement the unitary or prepare the state from a fixed product state. For a gate set $\delta(\Phi,Q)<\varepsilon,$0, let $\delta(\Phi,Q)<\varepsilon,$1 be the set of unitaries generated by circuits containing at most $\delta(\Phi,Q)<\varepsilon,$2 gates. Approximate state complexity can be defined by

$\delta(\Phi,Q)<\varepsilon,$3

when some $\delta(\Phi,Q)<\varepsilon,$4 prepares a state within trace distance $\delta(\Phi,Q)<\varepsilon,$5. Approximate unitary complexity uses diamond distance between the corresponding channels (Brandão et al., 2019).

Circuit size and circuit depth are distinct. Size counts elementary gates, whereas depth counts parallel layers. If gates on disjoint pairs are parallelized, depth can be smaller than size by a factor of order the number of qudits. In a sequential model they coincide.

Strong complexity

A stronger operational notion defines complexity through distinguishability rather than preparation. A pure state is compared with the maximally mixed state

$\delta(\Phi,Q)<\varepsilon,$6

If $\delta(\Phi,Q)<\varepsilon,$7 is the family of measurements implementable with at most $\delta(\Phi,Q)<\varepsilon,$8 local gates, the bounded-observer distinguishing bias is

$\delta(\Phi,Q)<\varepsilon,$9

Strong $\log(1/\varepsilon)$0-state complexity is at most $\log(1/\varepsilon)$1 when this bias is at least

$\log(1/\varepsilon)$2

The corresponding unitary definition compares a unitary channel $\log(1/\varepsilon)$3 with the completely depolarizing channel $\log(1/\varepsilon)$4 using ancilla-assisted input preparation and measurement. The optimal unrestricted bias is

$\log(1/\varepsilon)$5

Strong complexity implies a preparation lower bound, but the converse fails. A state can contain a highly complex subsystem together with one clean qubit; measuring the clean qubit may distinguish the state from $\log(1/\varepsilon)$6 even though preparing the whole state is difficult (Brandão et al., 2019).

This distinction separates preparation complexity, recognition complexity, design complexity, entanglement, and classical simulation complexity. None is generally equivalent to the others.

Complexity and unitary designs

An ensemble is an exact unitary $\log(1/\varepsilon)$7-design when its first $\log(1/\varepsilon)$8 moments agree with Haar measure. An approximate design satisfies a norm bound on the difference between the corresponding twirling channels. Increasing $\log(1/\varepsilon)$9 produces increasingly Haar-like behavior.

The relation between designs and complexity is probabilistic:

$P$0

Moment bounds, Markov’s inequality, and a union bound over all short measurements show that a sufficiently high-order design contains many unitaries and states that cannot be recognized by bounded-size circuits. For an approximate $P$1-design, exponentially many distinct high-complexity unitaries and states occur, and many can be chosen pairwise far apart in diamond or trace distance (Brandão et al., 2019).

The same mechanism yields a rigorous connection between random-circuit mixing and complexity growth. For qubit local random circuits, available design-growth theorems imply polynomial complexity growth. At sufficiently large local dimension, Haar-random two-site circuits generate designs after circuit size $P$2, giving linear complexity growth in the circuit size for most circuits. The full linear-growth conjecture for physically relevant qubit circuits over the entire exponential-time regime remains unproved.

3. Geometric and metric formulations

Quantum complexity can be formulated as a distance on the unitary group. For $P$3 qubits, the unitary group is

$P$4

with dimension $P$5. A circuit is represented by a path $P$6 from the identity to a target unitary. In Nielsen’s geometric formulation, the path length is determined by a right- or left-invariant metric that assigns larger costs to complicated many-body directions.

A typical metric decomposes the Hamiltonian generator into low-weight and high-weight components:

$P$7

where $P$8 projects onto one- and two-body terms, $P$9 onto higher-body terms, and $QMA$00 is a penalty factor. The complexity of $QMA$01 is the minimal geodesic length from the identity to $QMA$02.

This construction identifies position on the unitary manifold with the circuit endpoint, velocity with the instantaneous Hamiltonian, and geodesic distance with circuit complexity. The metric is not unique: changing the gate set, penalty factors, locality assumptions, or approximation tolerance changes the complexity.

Discrete, depth, and continuous complexity

For a finite computationally universal gate set $QMA$03, approximate gate complexity is a regularized word length. Exact synthesis is generically impossible: the dense subgroup $QMA$04 is countable and has Haar measure zero, so exact complexity is infinite for almost every unitary. At finite tolerance, Solovay–Kitaev-type bounds give logarithmic dependence on the inverse tolerance.

Circuit depth with an exactly universal continuous gate set is governed largely by parameter counting. If each layer contains at most $QMA$05 gates and each gate has $QMA$06 parameters, then a generic element of $QMA$07 requires depth at least

$QMA$08

Continuous complexity uses a cost function $QMA$09 on admissible Hamiltonian generators:

$QMA$10

For finite penalty factors this is generally a Riemannian or Finsler distance. In the limit where nonlocal directions are forbidden, it becomes a sub-Riemannian or Carnot–Carathéodory distance. If the admissible distribution is bracket-generating, Chow’s theorem guarantees finite distance between any two points.

Sub-Riemannian complexity is continuous but generically nondifferentiable. Ball-box geometry gives anisotropic scaling in which a direction generated only at commutator depth $QMA$11 has coordinate scale $QMA$12. The local Hausdorff dimension is

$QMA$13

which can exceed the ordinary manifold dimension. The resulting “fractal” behavior refers to metric scaling, not to a loss of smoothness of the underlying unitary group. Exact discrete word metrics and continuous Nielsen metrics can be computationally equivalent at algorithmic scales while remaining locally inequivalent.

Hydrodynamic large-$QMA$14 geometry

A large-$QMA$15 construction replaces the usual Pauli-weight basis with noncommutative plane waves $QMA$16 for $QMA$17. Their commutator is

$QMA$18

For low-momentum modes with $QMA$19,

$QMA$20

so the matrix algebra approaches the algebra of divergence-free vector fields on a two-torus:

$QMA$21

A Laplacian metric assigns polynomial penalties

$QMA$22

The Euler–Arnold equation becomes the two-dimensional incompressible, inviscid Euler equation,

$QMA$23

where $QMA$24 is a stream function. This model supplies a regular large-$QMA$25 complexity geometry with nonpositive average Ricci curvature, positive sectional-curvature directions, and conjugate points. Its correspondence with all of $QMA$26 is only a low-momentum correspondence, and its identification with holographic complexity is not established (Basteiro et al., 2021).

4. Complexity growth, saturation, and recurrence

For chaotic many-body evolution, a widely studied expectation is that complexity grows approximately linearly in time, continues growing after local entanglement has saturated, reaches a maximal value after an exponentially long interval, and remains near that value until extremely late recurrences.

Random local circuits provide a setting in which several parts of this picture can be proved. Approximate equidistribution means that sufficiently large balls have probabilities comparable to their Haar volumes. Since an $QMA$27-ball in unitary-channel space has volume approximately

$QMA$28

and an $QMA$29-ball in pure-state space has volume

$QMA$30

short-circuit regions occupy an exponentially small fraction of the full space. Consequently, typical approximate complexities satisfy

$QMA$31

where $QMA$32 is the Hilbert-space dimension (Oszmaniec et al., 2022).

After mixing, random local circuits remain at high complexity for intervals that are exponentially large in $QMA$33 for unitaries and in $QMA$34 for states. Since $QMA$35, these plateau durations are doubly exponential in the number of qudits. Recurrences arise when the random walk returns to a small neighborhood of a low-complexity circuit. The recurrence scales are approximately

$QMA$36

for unitary channels and

$QMA$37

for states. At fixed accuracy, these are doubly exponential in $QMA$38. Discrete random circuits also exhibit recurrence dips whose surrounding high-complexity regions have exponentially long duration.

These results do not prove that deterministic, time-independent chaotic Hamiltonians have the same design convergence. A fixed evolution

$QMA$39

has rigid eigenvalue correlations and generally explores a lower-dimensional phase torus rather than the full unitary group. Thus design convergence is a powerful tool for random or time-dependent dynamics but is not known to establish the full Brown–Susskind scenario for generic Hamiltonian evolution.

Scrambling and higher-order diagnostics

Ordinary entanglement entropy and four-point out-of-time-ordered correlators often saturate near the scrambling time. Complexity can continue growing beyond this point. Higher-order designs and generalized OTOCs provide diagnostics for this regime.

A $QMA$40-point OTOC contains $QMA$41 copies of a unitary and $QMA$42 copies of its adjoint. Its decay toward the Haar value indicates increasing design order. Recursive OTOCs can be constructed by repeatedly conjugating local operators:

$QMA$43

followed by further conjugations with generalized unitaries. Higher-order correlators typically remain nonzero longer than four-point correlators.

Numerical studies of automaton circuits found a hierarchy of decay times. If $QMA$44 denotes the time after which selected order-$QMA$45 correlators fall below a threshold, the observed scaling was summarized as

$QMA$46

This supports linear growth of design complexity in local qubit circuits, but the evidence is indirect because the correlator searches use restricted operator families. Automaton circuits nevertheless display Haar-like output statistics, Page-like entanglement, GUE-like entanglement-spectrum statistics, and high-order design signatures while remaining classically simulable. This establishes that entanglement, chaos-like diagnostics, design complexity, and classical simulation difficulty are distinct (Iaconis, 2020).

5. Resource-sensitive and operational complexity

Complexity can be assigned not only to states and unitaries but also to channels. A resource-dependent formulation begins with a set $QMA$47 of allowed gates, Hamiltonians, or Lindblad operators. The associated commutator seminorm is

$QMA$48

The Lipschitz complexity of a channel $QMA$49 is

$QMA$50

It measures the largest observable displacement produced by the channel relative to the resource-dependent gradient. The completely bounded version incorporates ancillary systems and entangled inputs.

The framework establishes faithfulness, convexity, subadditivity under composition, perturbation bounds, and complete tensor additivity for product resource sets. It applies to unitary channels, mixed-unitary channels, Hamiltonian simulations, quantum Markov semigroups, and open-system dynamics. For random circuits with a spectral gap, it yields probabilistic lower bounds on complexity growth before a model-dependent mixing scale. For finite-dimensional jump processes, complexity is linear before the return time and comparable to the maximal expected length after it. Infinite-dimensional diffusion can instead exhibit $QMA$51 behavior, showing that finite-dimensional linear growth is not universal (Araiza et al., 2023).

Wasserstein complexity

The quantum Wasserstein-1 distance is a locality-sensitive metric on states. For a traceless Hermitian operator $QMA$52, it is defined by decomposing $QMA$53 into components locally invisible outside individual sites:

$QMA$54

It satisfies

$QMA$55

Unlike trace distance, it can distinguish a change affecting one site from a change affecting every site. For example, the Wasserstein distance between $QMA$56 and $QMA$57 is $QMA$58, whereas their trace distance is $QMA$59.

The Wasserstein complexity of a channel is

$QMA$60

It is faithful, convex, subadditive under composition, bounded by the locality of the channel, and symmetric under inversion for unitary channels. Its correlation-assisted version permits ancillary entanglement and is additive under tensor products.

For two-local Nielsen generators, the continuous circuit cost obeys

$QMA$61

and the experimental cost obeys

$QMA$62

These are lower bounds on continuous or physical implementation costs, not exact lower bounds on discrete gate counts (Li et al., 2022).

Sensitivity, magic, and coherence

Influence is the expected Pauli weight of an operator. If $QMA$63 is its Pauli coefficient distribution, then

$QMA$64

It equals the infinitesimal decay rate under local depolarizing noise. Circuit sensitivity is

$QMA$65

For Nielsen two-local cost,

$QMA$66

Zero ordinary sensitivity characterizes unitaries generated by single-qudit unitaries and swaps. Such circuits are efficiently classically simulable on product inputs with local measurements. Gaussian sensitivity, defined with respect to Majorana weight, vanishes exactly for matchgates, the class of Gaussian or free-fermionic unitaries.

Influence is related to averaged OTOCs: increasing influence corresponds to decreasing averaged OTOC values and greater operator delocalization. A quantum Fourier entropy-influence inequality bounds Pauli Fourier entropy by influence, implying lower bounds on magic. Magic power and cohering power likewise lower-bound Nielsen circuit cost. These quantities are diagnostics and necessary resources, not complete characterizations of complexity; positive sensitivity, magic, or coherence does not by itself imply a quantum computational speedup (Bu et al., 2022).

Resource theory of uncomplexity

Uncomplexity is the remaining computational usefulness of a state relative to a maximal complexity. In a resource-theoretic formulation, the free operations are fuzzy gates: random nearby implementations of desired two-qubit gates. Fuzziness prevents arbitrarily long circuits from being treated as reliable computational operations.

The complexity entropy is

$QMA$67

where $QMA$68 contains measurements realizable with at most $QMA$69 gates. The quantity

$QMA$70

simultaneously measures extractable clean qubits and the clean-qubit cost of imitating the state to a bounded observer.

Two monotones are studied: brickwork uncomplexity and complexity negentropy,

$QMA$71

Fuzzy brickwork evolution decreases brickwork uncomplexity almost surely in specified architectures. Complexity negentropy is proven monotone only in restricted regimes and with specific success thresholds. General monotonicity, asymptotic reversibility, catalysts, and complete conversion rates remain open (Halpern et al., 2021).

6. Predictive, embedded, and dynamical notions of complexity

Complexity is also used to quantify the memory required for prediction. In computational mechanics, pasts are grouped into causal states when they induce identical conditional future distributions:

$QMA$72

The classical statistical complexity is the Shannon entropy of the stationary causal-state distribution,

$QMA$73

Quantum $QMA$74-machines encode causal states as nonorthogonal quantum states. Their memory density operator is

$QMA$75

and the proposed quantum $QMA$76-machine complexity is

$QMA$77

Because nonorthogonal states need not encode distinctions irrelevant to future prediction,

$QMA$78

For a thermalizing qubit cloud, $QMA$79 can remain nonzero for every partially thermalized state and then drop discontinuously to zero at complete randomness, whereas $QMA$80 rises and falls continuously. The authors do not prove that their quantum $QMA$81-machines are absolutely minimal; a true minimum $QMA$82 could satisfy

$QMA$83

Embedded complexity

Embedded complexity allows ancillas, intermediate measurements, and post-selection when preparing a target subsystem. A projected state has the form

$QMA$84

For a random circuit on $QMA$85 qubits of depth $QMA$86, the circuit volume is

$QMA$87

The embedded complexity of projected states is lower-bounded by a quantity scaling as

$QMA$88

in the relevant depth regime. Thus ancillas and measurements can reduce depth through gate teleportation and spacetime conversion without generically removing total gate volume. Random gate teleportation concentrates the volume of many subsystems onto one subsystem, while Clifford circuits permit efficient Pauli correction propagation.

The result gives an operational interpretation of circuit volume: generic projected states retain preparation cost proportional to the total spacetime resources used to generate them. A fully general approximate theorem for embedded complexity remains open (Du et al., 2024).

Krylov complexity

Krylov or spread complexity expands an evolving state in a Krylov basis obtained by Gram–Schmidt orthogonalization of its time orbit. For Haar-random brick-wall circuits, state K-complexity grows linearly at early times and saturates at approximately

$QMA$89

where $QMA$90 is the Hilbert-space dimension. The saturation time is of order $QMA$91. Measurements can alter the growth profile, while Floquet circuits with localized phases have reduced saturation values. This makes Krylov complexity a diagnostic of delocalization, thermalization, Anderson localization, and many-body localization rather than a direct measure of entanglement (Sahu et al., 2024).

7. Applications, interpretations, and unresolved issues

Quantum complexity has applications in quantum algorithms, verification, Hamiltonian simulation, quantum error correction, many-body dynamics, resource theories, quantum field theory, and holography. Quantum algorithms can provide rigorously established query improvements, including Grover’s quadratic search speedup, quantum walks, element distinctness, mean estimation, and Shor’s factoring and discrete-logarithm algorithms. Other proposed improvements for SAT, MIS, TSP, subset-sum, QAOA, quantum annealing, and hardware benchmarks are model-dependent, heuristic, empirical, or conditional. Apparent speedups can be altered by oracle construction, data loading, QRAM, error correction, hardware connectivity, embedding, classical optimization, and measurement costs (Vaezi et al., 2023).

Holographic and black-hole interpretations

The Brown–Susskind picture treats complexity as a quantity that grows after entanglement and local observables have equilibrated. A statistical “second law of quantum complexity” states that, away from saturation, generic evolution moves toward larger complexity with overwhelming probability. This is a counting statement: high-complexity regions contain vastly more states than low-complexity regions, but finely tuned reversals remain possible.

In AdS/CFT-inspired interpretations, entanglement establishes the existence and coarse geometry of an Einstein–Rosen bridge, while complexity is associated with the growth of its interior. The complexity–volume proposal identifies

$QMA$92

whereas the complexity–action proposal identifies complexity with the Wheeler–DeWitt action divided by $QMA$93. These are conjectural dictionaries rather than established theorems. Random-circuit saturation and recurrence results reproduce some qualitative features associated with black-hole interiors, but they do not derive them from a holographic gravitational theory (Russo, 2021).

Main limitations

Quantum complexity remains noncanonical for several reasons.

• Model dependence: gate sets, locality constraints, cost functions, penalty factors, approximation tolerances, and reference states change the value.
• Plurality of notions: gate count, depth, Nielsen distance, strong distinguishability complexity, Krylov complexity, Wasserstein complexity, sensitivity, magic, coherence, predictive memory, and embedded complexity capture different operational properties.
• Lower bounds are often one-sided: sensitivity, magic, coherence, and Wasserstein quantities certify cost but generally do not provide matching upper bounds.
• Randomness assumptions: rigorous growth, saturation, and recurrence theorems mainly concern random circuits, Brownian circuits, stochastic Hamiltonians, or ensembles with spectral gaps.
• Hamiltonian evolution: generic deterministic time-independent Hamiltonians do not straightforwardly converge to high-degree designs.
• Approximation effects: exact complexity can be discontinuous or infinite almost everywhere for finite dense gate sets, whereas approximate complexity depends sensitively on the error tolerance.
• Ancillas and measurements: they can reduce depth and redistribute computational work, but their effect on total complexity depends on whether volume, gate count, distinguishability, or subsystem preparation is being measured.
• Classical simulation: high entanglement, Haar-like statistics, GUE-like spectra, and high design order do not necessarily imply classical computational hardness.
• Resource-theoretic incompleteness: general monotonicity, asymptotic conversion rates, catalysis, reversibility, and a complete set of complexity monotones remain unresolved.
• Physical interpretation: identifications between entropy, circuit complexity, Kolmogorov complexity, hydrodynamic geometry, and holographic observables are partly heuristic.

The established landscape is therefore best viewed as a collection of related theories. Complexity classes describe computational solvability; circuit and geometric measures quantify implementation cost; design methods establish typical high complexity and long-time growth; resource-sensitive metrics provide operational lower bounds; predictive and embedded notions measure memory or subsystem preparation; and holographic proposals interpret complexity as a dynamical quantity beyond entanglement. No single measure has been shown to be universally appropriate for all quantum systems.