Tree-States: Measuring Quantum Complexity
- Tree-States are pure multiqubit states defined by rooted-tree representations where leaves hold one-qubit superpositions and internal nodes perform superposition or tensor-product operations.
- They provide a computable measure of quantum state complexity, with standard families like GHZ and W displaying polynomial tree sizes while determinant and permanent families exhibit superpolynomial growth.
- The framework interrelates tree size with tensor-network methods, offering insights into entanglement, recursive state decompositions, and the classical simulation of certain quantum computations.
Tree-states are pure multiqubit states represented by rooted trees whose leaves are one-qubit superpositions and whose internal vertices are superposition and tensor-product gates. The associated tree size is the minimum number of leaves over all such representations and serves as a computable measure of complexity for quantum states (Lê et al., 2013). Within this framework, simple families such as , , and fixed-bond-dimension matrix-product states have polynomial tree size, whereas explicit determinant and permanent families realize superpolynomial growth (Lê et al., 2013). Later work determined the maximal tree size for three- and four-qubit pure states, and adjacent tensor-network research developed distinct but related notions of tree tensor network states and binary tree states (Le et al., 2014).
1. Rooted-tree representation and tree size
For an -qubit pure state
a rooted-tree representation is built so that each leaf is labeled by a one-qubit superposition , each internal node is either a “” gate or a “” gate, and each edge descending from a gate carries a scalar weight. The size of such a tree is the number of leaves, and 0 is defined as the minimum number of leaves over all rooted-tree representations of 1 (Lê et al., 2013).
An equivalent recursive viewpoint starts from
2
and then decomposes each 3 in the same way. This gives the recursion
4
whose solution yields the trivial upper bound
5
for the maximum tree size over all 6-qubit states (Lê et al., 2013).
A central structural property is basis-independence under invertible local maps. If
7
with each 8 invertible, then 9 (Lê et al., 2013). In the language of few-qubit entanglement theory, the same statement appears as invariance under arbitrary invertible local operators, or SLOCC transformations (Le et al., 2014). This makes tree size a property of the state’s decomposition complexity rather than of an arbitrarily chosen local basis.
2. Explicit high-complexity families
The main explicit superpolynomial family is built from Raz’s lower bound for multilinear formulas computing the determinant, permanent, or any immanant with all nonzero coefficients. For the determinant one associates to an 0 bit-matrix the 1-qubit state
2
Because the multilinear-formula size of the associated function satisfies
3
Raz’s theorem implies
4
With 5, this is equivalently
6
The permanent family obeys the same type of lower bound (Lê et al., 2013).
The same family also admits a much smaller upper bound than the naive 7 expansion would suggest. Using the Laplace expansion of the determinant along a row, one obtains a recursive representation with leaf count 8 obeying
9
Induction gives
0
hence
1
The determinant and permanent therefore provide an explicit sequence of multiqubit states whose tree size is superpolynomial yet still far below the trivial exponential upper bound (Lê et al., 2013).
This separation is significant because it shows that tree size is neither a purely asymptotic stand-in for Hilbert-space dimension nor a restatement of coefficient sparsity. The determinant family is an explicit construction in which the minimal tree grows much faster than any polynomial, but its known upper bound remains factorial rather than exponential.
3. Polynomial tree size, entanglement, and simulation
Several standard families have small tree size, and bounded-bond-dimension one-dimensional tensor-network states are polynomially simple in this sense.
| Family | Tree-size statement |
|---|---|
| 2 | 3 |
| 4 | 5 |
| 1D-cluster | 6 |
| Open-boundary MPS, bond dimension 7 | 8 |
| Determinant/permanent families | 9 lower bound; 0 upper bound |
For an open-boundary MPS of 1 qubits with bond dimension 2,
3
inserting the resolution of the 4 identity between sites 5 and 6 yields a bipartition
7
From this one obtains
8
and therefore
9
In particular, any fixed-0 1D-cluster state with 1 has 2 (Lê et al., 2013).
Tree size is related to, but not identical with, entanglement measures. If a state has a minimal product-state expansion with 3 terms, then 4. Since 5 in terms of the Schmidt measure 6, one gets
7
For the determinant state, the Schmidt measure is 8, so the state is both highly entangled and highly complex (Lê et al., 2013). A plausible implication is that large multipartite entanglement alone does not determine tree-size complexity; the relevant issue is how efficiently the full state can be assembled from recursive sum-and-product structure.
The complexity notion also has algorithmic consequences. Any state with 9 admits a classical polynomial-size description and remains so under local measurements; hence measurement-based quantum computation on such states is classically simulable. The same work presents this as an explanation for why 2D cluster states, conjectured to have superpolynomial tree size, are universal resources (Lê et al., 2013).
4. Exact results for few qubits and smoothed tree size
For three qubits, tree size is completely classified by the usual entanglement classes. Product states have 0, biseparable states have 1, the GHZ class has 2, and the 3 class has 4; the maximal tree size is therefore 5, reached for instance by 6 (Le et al., 2014). The proof strategy combines exhaustive analysis of small trees with the SLOCC classification of three-qubit entanglement.
For four qubits, the maximal tree size is 7, reached for instance by a state called 8, which had already been discussed in the context of four-photon down-conversion experiments (Le et al., 2014). A notable feature of the four-qubit case is that the most economic description of a state is found not to be recursive. The paper isolates a class of states with irreducible 9 form: no choice of partition 0 and no invertible local operation on 1 can make either branch leave the 2 class. For such states, exhaustive elimination shows that no tree of size 3 suffices, while a size-4 decomposition exists (Le et al., 2014).
The same study introduced a smoothed notion,
5
to model finite experimental precision. The states with maximal tree size form a set of zero measure: for three qubits the maximal 6-tree size drops from 7 to 8, and for four qubits it drops from 9 to 0 (Le et al., 2014).
A mixed-state version was also defined,
1
and discussed for a one-parameter family of generalized Werner states (Le et al., 2014). This extends tree-size complexity from pure-state description length to ensemble-based mixed-state complexity.
5. Related but distinct notion: tree tensor network states
In tensor-network theory, tree tensor network states (TTNS) form a separate notion from tree size. A TTNS is a variational ansatz for a many-body wavefunction that generalizes matrix product states from a one-dimensional chain to an arbitrary acyclic (“tree”) graph. In a TTNS of 2 sites, each site 3 is associated with a tensor
4
where 5 is the physical index, the 6 are bond indices of dimension up to 7, and 8 is the number of incident tree edges; the global wavefunction is obtained by contracting all bond indices according to the tree connectivity (Rano et al., 27 Jun 2025). An MPS is the special case in which the tree is a path.
This ansatz has been developed extensively in quantum chemistry and vibrational many-body theory. An efficient TTNS algorithm for quantum chemistry introduced half-renormalization and found that tree tensor network states require much fewer renormalized states to achieve the same accuracy as matrix product states, while also emphasizing that the higher prefactor and computational scaling can offset this advantage in non-tree molecules; a large dendrimer calculation correlated 110 electrons in 110 active orbitals (Nakatani et al., 2013). For vibrational eigenstates, TTNS-based DMRG-style optimization was applied to acetonitrile and compared directly with MPS; for that system no major advantage of the more general TTNS over MPS was found, but adaptive bond dimension significantly reduced the number of required parameters (Larsson, 2019). A later inexact Lanczos method combined with TTNS computed excited vibrational states for acetonitrile, the Zundel ion, and the Eigen ion (Rano et al., 27 Jun 2025).
Several later developments refined the TTNS paradigm. The three-legged tree tensor network state (T3NS) intersperses physical tensors with branching tensors so that physical tensors have one physical index and at most two virtual indices, while branching tensors have no physical index but up to three virtual indices; this combines low computational cost and simple implementation of symmetries with the larger entanglement capacity of tree geometries (Gunst et al., 2018). On the information-theoretic side, the task of testing whether an unknown pure state is a TTNS on 9 qudits with bond dimension at most 0 was shown to require 1 copies for a one-sided-error tester, with a matching lower bound 2 up to logarithmic factors when 3 (Lovitz et al., 2024). A later approximation theorem showed that TTNS approximation error can be bounded using Schmidt spectra or Rényi entanglement entropies, and that for tree lattices efficient TTNS approximations exist if 4 Rényi entanglement entropies for single-branch cuts obey an area law (Barthel, 23 Dec 2025).
These results make clear that tree size and TTNS bond dimension address different questions. Tree size measures the minimum length of a recursive bra-ket expression, whereas TTNS specifies a variational manifold of tensor contractions on a fixed acyclic graph. This suggests a family resemblance based on tree-structured factorization, but not an equivalence of complexity notions.
6. Binary Tree States and broader tree-based constructions
A further nearby usage is the Binary Tree State (BTS). BTS are states whose decomposition on a quantum register basis formed by a set of qubits can be made sequentially. One introduces
5
and defines
6
Because 7, each term in 8 picks out exactly 9 distinct qubits to flip from 00 to 01, and the state admits a sequential binary-tree decomposition obtained by peeling off qubits one by one (Lacroix, 2024).
This framework includes Dicke states and particle-number-projected BCS states. For a bipartition into a 02-qubit subsystem 03 and its complement 04, BTS admit an exact Schmidt decomposition
05
with
06
The 07-qubit von Neumann entropy is therefore
08
with upper bounds 09 and, when 10, 11 (Lacroix, 2024). In the Dicke case, the Schmidt weights reduce to the hypergeometric law, and for large 12 the entropy is approximated by
13
Tree-based constructions also appear outside the original tree-size setting. A stacked tree construction for free-fermion projected entangled pair states first builds a tree tensor network description in local subregions, then applies a stacking procedure and local compression to obtain a PEPS representation (He et al., 2023). In probabilistic modeling, generative modeling via tree tensor network states uses the Chow–Liu algorithm to determine tree topology and sketching techniques to obtain linear systems defining the tensor-network components, with sample complexity guarantees (Tang et al., 2022).
Taken together, these lines of work show that “Tree-States” is not a single formalism but a family of closely related tree-structured descriptions. In the tree-size literature, the emphasis is exact classical description complexity; in TTNS, it is variational representation and computation; in BTS, it is sequential decomposition and entanglement analysis for symmetry-adapted states.