Classifying One-Dimensional Quantum States Prepared by a Single Round of Measurements
Rahul Sahay Ruben Verresen




Department of Physics, Harvard University, Cambridge, Massachusetts 02138 USA

Department of Physics, Harvard University, Cambridge, Massachusetts 02138 USA
Department of Physics, Massachusetts Institute of Technology, Cambridge, MA 02139, USA




Measurements and feedback have emerged as a powerful resource for creating quantum states.

However, a detailed understanding is restricted to fixed-point representatives of phases of matter.

Here, we go beyond this and ask which types of many-body entanglement can be created from measurement.

Focusing on one spatial dimension, a framework is developed for the case where a single round of measurements are the only entangling operations.

We show this creates matrix product states and identify necessary and sufficient tensor conditions for preparability, which uniquely determine the preparation protocol.

These conditions are then used to characterize the physical constraints on preparable quantum states.

First, we find a trade-off between the richness of the preparable entanglement spectrum and correlation functions, which moreover leads to a powerful no-go theorem.

Second, in a subset of cases, where undesired measurement outcomes can be independently paired up and corrected, we are able to provide a complete classification for preparable quantum states.

Finally, we connect properties of the preparation protocol to the resulting phase of matter, including trivial, symmetry-breaking, and symmetry-protected topological phases—for both uniform and modulated symmetries.

This work offers a resource-theoretic perspective on preparable quantum entanglement and shows how to systematically create states of matter, away from their fixed points, in quantum devices.


Classifying One-Dimensional Quantum States
Prepared by a Single Round of Measurements
    Ruben Verresen
    April 29, 2024
=====================================================================================







§ INTRODUCTION


Emergence in many-body quantum states can give rise to remarkable physical properties <cit.>. Indeed, decades of exploration have revealed a plethora of possible phases of matter, including symmetry-breaking states and more exotic `topological' states <cit.>. In one spatial dimension, a complete classification has even been achieved for ground states of local gapped Hamiltonians, including symmetry-protected topological (SPT) states with interesting edge mode properties <cit.>.
However, knowing the physical properties of a many-body quantum state is quite different from knowing how to create it. This has become of increasing importance due to the rapid development of quantum technologies <cit.> and raises the question: which states of matter can be created with the capabilities of a given platform? This question is even of fundamental importance, since from a resource-theoretic perspective, we learn something new about a state if we know what it takes to create it.

A conceptual and practical development in the efficient preparation of many-body quantum states is the use of measurements. Although this is a rather novel ingredient in the context of condensed matter physics—where one has typically focused on the unitary aspects of quantum physics—the use of measurement has a rich history in quantum information theory <cit.>. In particular, the idea of error correction <cit.> naturally suggests that certain `stabilizer states' (including the famed GHZ and toric code states <cit.>) can be prepared via measurement-and-feedback <cit.>. In stark contrast to the case with only unitary circuits <cit.>, measurements allow one to achieve these tasks in a time (or `circuit depth') which is independent of system size[More precisely, the `quantum time' is finite, by which we mean the depth of the quantum operations in the circuit; classical information-gathering and -processing still has a linear overhead, but such ingredients tend to be cheap and are only limited by the speed of light.].

Recent years have seen rapid progress in developing new ways of preparing many-body states using measurement, both at the theory level <cit.> as well as experimental implementations <cit.>. However, most measurement-based works consider the deterministic preparation of fixed-point states: while these can represent exotic states of matter, such fixed-point states have rather featureless correlation functions and entanglement spectra. Two notable exceptions are the deterministic constant-depth preparation of the spin-1 AKLT state <cit.> and of certain wavefunction deformations of the trivial and GHZ states (Appendix G of Ref. zhu2023nishimori). These constitute examples of states with non-trivial correlation length 0 < ξ < ∞ which can nevertheless be deterministically prepared in finite time using measurement. The existence of such examples is a priori surprising since it means that all measurement outcomes must give states which are exactly related by a finite-depth unitary operation; this property seems in tension with non-trivial correlations.

Emboldened by these limited examples, we explore the question: what types of many-body entanglement and correlation functions can possibly arise from a measurement-based protocol? In addition to the immediate practical relevance, an answer to this type of question can give insight into the nature of phases of matter and entanglement—similar to knowing how the inability of preparing the toric code using finite-depth unitary circuits <cit.> captures part of the essence of the toric code itself. If we hope to provide a crisp answer, we must provide a crisp list of ingredients of what we do (not) allow. To single out the power of measurement, we will explore a measurement-only protocol: measurement will be the only entangling operation. Moreover, in this work we will allow only a single layer of measurement. Despite this restrictive setting, we will see that the resulting landscape is remarkably rich and structured, even in one spatial dimension.

While we provide a detailed description of our set-up in Sec. <ref>, let us give a brief taste of what we consider:

    Ingredients (Informal) We explore and characterize one-dimensional quantum states which are deterministically preparable with the following ingredients: 
    
        
  (1) An initial product state of disentangled clusters (shown in blue)

        
  (2) Finite-range complete-basis measurements on a subset of sites (white)

        
  (3) On-site (i.e., non-entangling) unitary feedback conditioned on measurement outcomes (orange). 
        
    
    
    Schematically:
    
    < g r a p h i c s >


These ingredients are in part inspired by those used in Ref. smith2023aklt for preparing the AKLT state, although we have minimized our assumptions (e.g., we do not presume that the measurement basis is fully-entangled, also called a fusion measurement <cit.>). Let us also stress that we demand deterministic state-preparation, which means we can correct for any possible measurement outcome. This is in contrast to works which consider approximate, probabilistic or partial preparation, whereby one prepares, e.g., mixed states <cit.>  or (arbitrarily-good) approximations to the target state <cit.>.

In this work, we detail the physical properties of states which can result from the above set of ingredients. A general insight that emerges is that such states can have very rich entanglement spectra and very rich correlation functions—but not at the same time. Indeed, we find a trade-off between the two. This is crystallized by proving a no-go theorem for states which cannot be prepared in this way.

These and other results follow from a general framework we develop. This is built on the observation that any state obtained from these ingredients must be a matrix product state (MPS) <cit.>. Using the MPS formalism, we are then able to convert the above list of ingredients into necessary and sufficient conditions on the MPS tensors which guarantee preparability of the state. Remarkably, if an MPS tensor satisfies these conditions, it also essentially specifies the preparation protocol.

The advantage of this approach is that once we have encoded these ingredients into conditions on the local MPS tensor, we can study what physical properties are implied by these conditions. This leads to a series of results, such as general connections between the feedback-protocol and the resulting phase of matter, and even to classifications of preparable states in a subset of cases. To make these results broadly accessible, Sec. <ref> introduces key ideas through examples and informally states some of our key results without requiring MPS-based language.

After the overview section (Sec. <ref>), we go over the basic ingredients in Sec. <ref>. We show how this implies an MPS description of the state, along with the local characterization which guarantees preparability. In Sec. <ref> we explore the case where feedback requires non-local classical communication. We relate this to various physical quantities, such as a degenerate entanglement spectrum, and we even present full classifications in certain cases. This is followed by Sec. <ref>, which also studies the case with local error correction. The latter culminates in the aforementioned no-go theorem.



§ MOTIVATING EXAMPLES AND PRELUDE OF RESULTS


Before delving into a general formalism for characterizing states preparable using the ingredients above, we begin with an informal prelude of our results.

Specifically, we discuss three examples of deterministically preparable states, each of which elucidates aspects of the general problem.

We subsequently highlight the essential features of these examples that generalize, stating informally and without proof the key physical ideas and results of this work with formal statements postponed to later sections.

Readers seeking a sense of what can be prepared with the ingredients above and a conceptual précis of what constraints preparability places on quantum states can choose only to read this section.

Alternatively, those interested in the general formalism and not requiring motivating examples are encouraged to read only Sec. <ref> of this section, before going to the next section.






 §.§ Example 1: Deformed GHZ State 


For our first motivating example, we describe the preparation protocol for a parameterized class of long-range entangled wavefunctions, which spontaneously break a ℤ_2 spin-flip symmetry.

The wavefunctions are given by 

    |Ψ(β)⟩   ∝exp( β∑_x = 2^N -1 X_x ) |GHZ_N⟩
       = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightdodgerblue] (0, 0) rectangle (3.6, 0.4);
            ı in 0, ..., 6
            [color = black] (0.1 + 0.57*ı, 0) – (0.1 + 0.57*ı, -0.5);
            
            ;
            ı in 1, ..., 5[fill = white] (0.1 + 0.57*ı, -0.25) circle (0.1);
            ;
             at (1.8, 0.2) GHZ_N;

that are deformed versions of the standard GHZ state beyond its fixed point (where boundary perturbations are omitted to simplify the discussion[This guarantees deterministic state-preparation. Boundary perturbations still allow for statistical state-preparation, with a success probability independent of system size.]).

Here, the white circles are the non-unitary time-evolution e^β X (β∈ℝ) and |GHZ_N⟩∝(|0⋯ 0⟩ + |1 ⋯ 1⟩) is the standard GHZ state defined on a one-dimensional chain of N qubits and X, Y, Z are the Pauli matrices. One can straightforwardly confirm this state retains its `cat state' nature for all β < ∞:

    ∏_x=1^N X_x | Ψ(β)⟩ =| Ψ(β)⟩, ⟨Ψ(β) | Z_x Z_y≠ x | Ψ(β) ⟩ = (2β)^2.

However, for 0 ≠β < ∞ this state has non-trivial correlation lengths[This is evidenced by its symmetry string correlator ∏_x=a>1^b<N X_x decaying as e^-|b-a|/ξ with ξ = -1/lntanh(2β).]. Our preparation protocol will generalize the one in Ref. <cit.>, which considered β=0.

In line with the ingredients presented in the introduction, we prepare this state by starting with a product state of (N-2) decoupled three-qubit states[Each state can be unitarily obtained from |GHZ_3⟩ as e^-i t Z_l_x Y_c_x|GHZ_3⟩ with tan t = tanhβ.]:

    |Ψ_0(β)⟩   ∝⊗_x = 2^N-1 e^β X_c_x|GHZ_3⟩_l_x, c_x, r_x
       =⋯[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.4);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.4);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.4);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.2) circle (0.1);
            
            
            ;
            
            
         ⋯

where l_x, c_x, r_x label the center, left, and right qubit of the three qubit cluster.

Subsequently, we perform nearest-neighbor measurements between qubits r_x and l_x + 1 on the above cluster in the Bell basis:

    |1⟩ = 1/√(2)(|00⟩ + |11⟩)  |X⟩ = 1/√(2)(|01⟩ + |10⟩) 
       |Z⟩ = 1/√(2)(|00⟩ - |11⟩)  |ZX⟩ = 1/√(2) (|10⟩ - |01⟩)

which satisfy |V⟩_12 = V_2|1⟩_12 = V_1^†|1⟩_12.

To understand the result of this, let us consider the case where each of the measurement outcomes yield the |1⟩ Bell state.

In this case, the post-measurement state on the unmeasured qubits is:

    ( ⊗_x = 1^N - 3⟨1|_r_x l_x + 1)|Ψ_0(β)⟩∝⋯[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightdodgerblue] (0,0) rectangle (1, 0.4) ;
            [rounded corners, fill = lightdodgerblue] (1.3,0) rectangle (2.3, 0.4) ;
             at (0.5, 0.2) GHZ_3;
             at (1.8, 0.2) GHZ_3;
            [color = black] (0.1, 0) – (0.1, -0.25);
            [color = black] (0.5, 0) – (0.5, -0.65);
            [color = black] (0.9, 0) – (0.9, -0.5);
            [color = black] (1.4, 0) – (1.4, -0.5);
            [color = black] (1.8, 0) – (1.8, -0.65);
            [color = black] (2.2, 0) – (2.2, -0.25);
            [fill = white] (0.5, -0.3) circle (0.1);
            [fill = white] (1.8, -0.3) circle (0.1);
            [rounded corners, fill = lightishgray] (0.8,-0.25) rectangle (1.5, -0.55) ;
             at (1.15, -0.4) ⟨1|;
         ⋯

where the white circles indicate the e^β X operator appearing in the initial cluster and time runs downwards.

Note that, the projector onto the |1⟩ state will “glue” the neighboring GHZ_3's together to a many-body wavefunction.

Specifically, since the projector ⟨1| enforces the qubits r_x and l_x+1 to be in the same computational state and the |GHZ_3⟩_x state has the property that each of its three qubits are in the same computational state, the result of this “gluing” will be to produce a many-body GHZ state on the N unmeasured qubits.


Further taking into account the e^β X gates, we conclude that, in the case where all measurement outcomes yield |1⟩, the resulting wavefunction is the desired target state |Ψ(β)⟩ with no unitary  feedback necessary.

Now, let us consider what happens for an arbitrary measurement outcome.

For example, the circuit diagram for such an outcome may look like:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            
            
            
            [rounded corners, fill = error-red] (0.8 + 1.3*0,-0.25) rectangle (1.5 + 1.3*0, -0.55) ;
            [rounded corners, fill = lightishgray] (0.8 + 1.3*1,-0.25) rectangle (1.5 + 1.3*1, -0.55) ;
             at (1.15, -0.4) ⟨X|;
             at (1.15 + 1.3, -0.4) ⟨1|;
            
          = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.4, -0.3) X;


Here, a measurement outcome of anything other than |1⟩ will be referred to as an error, that needs to be corrected by acting a tensor product unitary at the physical level.

To see how a |X⟩ measurement error is to be corrected, we remark upon a convenient property of the GHZ state.

Namely, X_l_x|GHZ_3⟩_x = X_c_x X_r_x|GHZ_3⟩.

Consequently, we have that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.4, -0.3) X;
            
             at (2.4, -1.1) ;
            
          =     [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
            
             at (0.9 + 1.3, -0.3) X;
             at (0.5 + 1.3, -0.6) X;
            [color = red, fill = none] (0.7 + 1.3, -0.9) rectangle (1.6 + 1.3, -0.1);
             at (2.4, -1.1) =⟨X|;

where we used the fact that X commutes through e^β X.

The above can be iterated and shows that measurement outcomes that result in an |X⟩ can be corrected by “sweeping” the measurement error to the right by acting with a physical unitary string of X's from the location of the error to the boundary.

Similarly, the GHZ state has the property that and Z_l_x|GHZ_3⟩_x = 1_c_x Z_r_x|GHZ_3⟩_x implying that |Z⟩ measurement outcomes can be similarly swept to the right, with no required action at the physical level except for a local Z correction applied at the boundary.

Finally, corrections of |ZX⟩ proceed similarly by using a combination of the techniques for X and Z.

This demonstrates that the quantum state in Eq. (<ref>) can be prepared deterministically using the ingredients referenced in the introduction.

Let us take stock of the qualitative features of the measurement protocol and the physical properties of the resulting state.

We saw that correcting a measurement error involved “sweeping” it off to the boundary. This means that a single error is corrected by a physical unitary action which was spatially delocalized from the location of the error. We call such errors topological (indeed as we discuss later, they correspond to defects in either long-range entangled phases or in symmetry-protected topological phases).

Equivalently, the feedback-unitary applied at a given physical site was non-locally conditioned on the classical data of every measurement outcome to the left of it.


The fact that all errors are non-locally corrected requires that the post-measurement state has the ability to `teleport' information across the system. In Sec. <ref> we will prove quite generally that this necessitates the post-measurement state to have a flat entanglement spectrum, congruent with intuition gained from measurement-based quantum computation <cit.>. Indeed, |Ψ(β)⟩ has a bipartite entanglement spectrum given by  Λ^2 = (1/2, 1/2), similar to the GHZ state.

Furthermore, the state has the seemingly unrelated property that it has no observables with zero correlation length (which we define in Sec. <ref>). We will later show that this is no accident.

By considering two more examples, we will phenomenologically motivate a key result of our work that these properties of the state are direct consequences of the fact that each measurement error is non-locally corrected.



 §.§ Example 2: Deformed Cluster SPT State 


Our next motivating example is a class of wavefunctions in the non-trivial symmetry-protected topological (SPT) phase protected by a ℤ_2 ×ℤ_2 symmetry generated by spin-flips on even and odd sublattices.

The wavefunctions are given by:

    |Ψ(β)⟩∝exp( β∑_x = 2^N -1 X_x ) |cluster_N⟩

which are now deformed versions of the N-qubit “cluster” state, defined as the state stabilized by Z_x X_x + 1 Z_x + 2 in the bulk and X_1 Z_2 and Z_N-1 X_N at the boundary <cit.>.

Physically, such states are short-range entangled but share many features in common with the deformed GHZ state.

In particular, they similarly have a flat bipartite entanglement spectrum given by  Λ^2 = (1/2, 1/2) and also have the property that every connected correlation function that is not identically zero has exponentially decaying tails (see Appendix <ref>).

We now show that these shared physical properties between the GHZ  are accompanied by a similarity in the correction of measurement errors in the preparation of |Ψ(β)⟩.

To see this, we note that this state is prepared by first preparing the same product state of (N - 2) decoupled clusters as in the first example [c.f. Eq. (<ref>)] but instead of measuring in the Bell basis, we measure in a basis related to it by a Hadamard gate H, acting on the first qubit, e.g. our basis is |V'⟩ = H_r_x|V⟩ = H_r_x V_l_x + 1|1⟩.

The claim is then when all the measurement outcomes are H_r_x|1⟩:

    ( ⊗_x = 1^N - 3⟨1|_r_x l_x + 1 H_r_x)   |Ψ_0(β)⟩∝⋯[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightdodgerblue] (0,0) rectangle (1, 0.4) ;
            [rounded corners, fill = lightdodgerblue] (1.3,0) rectangle (2.3, 0.4) ;
             at (0.5, 0.2) GHZ_3;
             at (1.8, 0.2) GHZ_3;
            [color = black] (0.1, 0) – (0.1, -0.25);
            [color = black] (0.5, 0) – (0.5, -0.65);
            [color = black] (0.9, 0) – (0.9, -0.5);
            [color = black] (1.4, 0) – (1.4, -0.5);
            [color = black] (1.8, 0) – (1.8, -0.65);
            [color = black] (2.2, 0) – (2.2, -0.25);
            [fill = white] (0.5, -0.3) circle (0.1);
            [fill = white] (1.8, -0.3) circle (0.1);
            [rounded corners, fill = lightishgray] (0.8,-0.5) rectangle (1.5, -0.8) ;
             at (1.15, -0.65) ⟨1|;
            
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
         ⋯
       =[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightdodgerblue] (0, 0) rectangle (3.6, 0.4);
            ı in 0, ..., 6
            [color = black] (0.1 + 0.57*ı, 0) – (0.1 + 0.57*ı, -0.5);
            
            ;
            ı in 1, ..., 5[fill = white] (0.1 + 0.57*ı, -0.25) circle (0.1);
            ;
             at (1.8, 0.2) cluster_N;
            [fill = lightorange(ryb)] (0.1, -0.25) circle (0.1);
            [fill = lightorange(ryb)] (0.1 + 6*0.57, -0.25) circle (0.1);


where the orange circle is the Hadamard matrix.

The above can be easily verified by showing that, when β = 0, the state is stabilized by Z_x X_x + 1 Z_x + 2 in the bulk and  X_1 Z_2 and Z_N-1 X_N at the boundary (see Appendix <ref>).



For an arbitrary measurement outcome, we see that the correction indeed proceeds similarly to the first example, with:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.3) circle (0.1);
            [fill = white] (1.8, -0.3) circle (0.1);
            
            ;
            [rounded corners, fill = error-red] (0.8 + 1.3*0,-0.25 - 0.25) rectangle (1.5 + 1.3*0, -0.55 -0.25) ;
            [rounded corners, fill = lightishgray] (0.8 + 1.3*1,-0.25 - 0.25) rectangle (1.5 + 1.3*1, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨X|;
             at (1.15 + 1.3, -0.65) ⟨1|;
            
            
            
            
            
            
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (2.2, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (3.5, -0.3) circle (0.1);
            
          =       [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.5 + 1.3*ı, -0.3) circle (0.1);
            [fill = white] (1.8, -0.3) circle (0.1);
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.8, -0.65) X;
            
             at (3.5, -0.65) X;
            
            
            
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (2.2, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (3.5, -0.3) circle (0.1);

following from the GHZ identities we have regularly used.

The above implies that measurement outcomes that result in an |X⟩ at location x can be corrected by “sweeping” the measurement error to the right by acting with the string ∏_y ≥ 0 X_x + 2y from the location of the error to the boundary.

A similar analysis shows that measurement outcomes that result in an |Z⟩ or |ZX⟩ at location x can be corrected by “sweeping” the measurement error to the right by acting with strings ∏_y ≥ 0 X_x + 2y + 1 or ∏_y ≥ 0 X_x + y from the location of the error to the boundary.

Consequently, the quantum state in Eq. (<ref>) can also be prepared deterministically using the ingredients referenced in the introduction.

Moreover, similar to the GHZ, each type of measurement error was non-locally corrected.

We note that this preparation protocol resembles the one introduced in Ref. smith2023aklt for preparing the AKLT state <cit.>, although here we have a tunable correlation length. Crucially, we now turn to an example whose preparation and physical properties are radically distinct.



 §.§ Example 3: Deformed Trivial State 


We conclude by discussing one final representative class of examples, which have both qualitatively different physical properties accompanied by a qualitatively different preparation protocol.

The examples are given by[One can also include the term for x=1 at the expense of applying an additional e^α X_l_1 factor on the first cluster in Eq. (<ref>).]:

    |Ψ(β)⟩∝exp( β∑_x = 2^N -1 Z_x Z_x + 1) |+⟩^⊗ N

which are short-range entangled wavefunctions in the trivial phase for all β < ∞ that asymptote to the GHZ state exactly at β = ∞.

In this case, the state is preparable by first preparing the following entangled clusters:

    |Ψ_0(β)⟩∝⊗_x = 1^N e^α X_r_x|GHZ_3⟩_l_x, c_x, r_x

with α = arctanh(e^-2β). Crucially, while this looks similar to Eq. (<ref>), note that the imaginary time-evolution is now on the right rather than the central qubit of each cluster.

Subsequently, we again measure in the familiar Bell basis (<ref>).

We show in Appendix <ref> (using tensor network state methods) that in the case where each of the measurement outcome yields the |1⟩ Bell state, the post-meaurement state is exactly |Ψ(β)⟩.

We turn to discussing the correctability properties of the state.


Similar to the GHZ and cluster state case we find that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.9 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            
            
            
            [rounded corners, fill = error-red] (0.8 + 1.3*0,-0.25 - 0.25) rectangle (1.5 + 1.3*0, -0.55 -0.25) ;
            [rounded corners, fill = lightishgray] (0.8 + 1.3*1,-0.25 - 0.25) rectangle (1.5 + 1.3*1, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨X|;
             at (1.15 + 1.3, -0.65) ⟨1|;
            
            
            
          =     [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.9 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.8, -0.6) X;
             at (3.1, -0.6) X;
             at (3.5, -0.6) X;

which is to say that |X⟩ at location x can be corrected by “sweeping” the measurement error to the right by acting with the string ∏_y ≥ 0 X_x + y from the location of the error to the boundary.

However, unlike the other two cases, a |Z⟩ error is corrected as: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            [fill = white] (0.9 + 1.3*ı, -0.3) circle (0.1);
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
            [rounded corners, fill = error-red] (0.8 + 1.3*0,-0.25 - 0.25) rectangle (1.5 + 1.3*0, -0.55 -0.25) ;
            [rounded corners, fill = lightishgray] (0.8 + 1.3*1,-0.25 - 0.25) rectangle (1.5 + 1.3*1, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨Z|;
             at (1.15 + 1.3, -0.65) ⟨1|;
          =     [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            [fill = white] (0.9 + 1.3*ı, -0.3) circle (0.1);
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.8, -0.6) Z;
             at (3.1, -0.6) ;
             at (3.5, -0.6) ;

which is entirely local (i.e. no need for infinite strings or correction at the boundary). We call this a local error.


As stated earlier, the difference in the correction properties of the errors in this example are accompanied by different physical properties.

Unlike the other two examples, here the entanglement spectrum is not flat: one can calculate that Λ^2 = (1/2 + δ,1/2 - δ) with δ^-1 = e^2β+e^-2β. Indeed, now there is no longer a need for being able to teleport arbitrary Pauli matrices.


Moreover, we prove in Appendix <ref> that, unlike the other two examples, there exists an operator with a strictly finite range of correlations that does not exponentially decay (i.e. its correlation length is zero)[In particular, if we define 𝒪^L_n = Z_n+1 X_n+1 e^-2β Z_n Z_n+1 and 𝒪^R_n = X_n Z_n e^-2β Z_n Z_n+1 then ⟨𝒪^L_2m𝒪^R_2n⟩ equals tanh(2β) if n=m+1 but vanishes for n>m+1.], although other operators have nonzero correlation length ξ∼ 1/|lntanhβ|.




 §.§ Informal Prelude of Results
 

With these motivating examples in hand, our results fall into two categories which we summarize below. In these cases we refer to states as `gluable' if they can be prepared with the above ingredients: decoupled clusters which are `glued' together with a single-round of complete-basis measurements. In the above examples, we saw errors could be swept in a single direction. We will generally require that measurement errors can be corrected by conditioning only on gates to the left. For a detailed discussion of the ingredients, we refer to Sec. <ref>.




  §.§.§ Interplay Between Preparability, Entanglement, Correlations, and Order


A key physical result of our work is a relationship between how a state is prepared using measurement, and the physical properties of the resulting state (in particular, its correlation lengths, entanglement spectrum, and phase of matter).

To give a taste of these general results, we highlight five informally stated theorems, whose precise statements are in the parenthetically referenced sections below: 

    
  I. Theorem (Non-Local Correction Constrains Entanglement Spectrum) If a wavefunction is preparable by gluing and all measurement errors require non-local correction, then its bipartite entanglement spectrum Λ^2 is constrained to be flat (Sec. <ref>).

    
  II. Theorem (Local Correction Constrains Correlations) If a wavefunction is preparable by gluing and there exists a measurement error that can be locally corrected, then there exists an operator with zero correlation length (Sec. <ref>).


A corollary of the above theorems is a powerful no-go theorem:


    
  III. Theorem (No-Go Theorem) Suppose |Ψ⟩ is a wavefunction whose entanglement spectrum Λ^2 is not flat. If there does not exist an operator whose connected correlation function in |Ψ⟩ has a zero correlation length, then |Ψ⟩ is not preparable with the ingredients listed in the introduction (Sec. <ref>).


Despite this powerful restriction on the class of preparable many-body wavefunctions, we prove that the landscape of preparable states are rich.

This is exemplified by the following “go theorem” 

    
  IV. Theorem (Go Theorem) Let |Ψ⟩ be in a non-trivial SPT phase for abelian on-site symmetries. If it has minimal entanglement (i.e., the bipartition of an infinite chain has the smallest Schmidt rank allowed by the non-trivial SPT phase), then it is gluable with the above ingredients.

Note that our second example (Sec. <ref>) is a special case of this general theorem, for the abelian group ℤ_2 ×ℤ_2 and Schmidt spectrum Λ^2 = ( 1/2 , 1/2).

We also have a converse for this theorem, which arises as a special case of a classification of gluable states:

    
  V. Theorem (Classification) We have a full classification of gluable states (shown in Eq. (<ref>)) if: (i) all errors are non-locally corrected; (ii) all errors commute up to phase (which means that correcting one error does not affect other errors); (iii) and the errors satisfy a technical homogeneity condition.

    In the special case of short-range entangled cases, this classification tells us the state must be a minimally entangled state for a non-trivial abelian SPT phase (Sec. <ref>).

Such a classification highlights that precise answers can be found to the question of which states can be prepared with certain measurement-based resources. Once one is in possession of this closed-form solution of gluable states, their physical properties can be gleaned. In fact, one can use this to even engineer preparable states with certain desired properties; the latter is illustrated in our companion work <cit.>.



  §.§.§ Connection to Matrix Product States and Required Resources for Preparability


Our second class of results connects preparable states to matrix product states (MPSs) <cit.> and further constrains the possible ways in which one could create interesting correlated states.

These class of results inform one “where to look” if one wants to prepare a given quantum many-body state from the ingredients above.


    
  I. Theorem Every gluable quantum state is a matrix product state.

    
  II. Theorem (Requirements on Initial Clusters) The initial entangled clusters are guaranteed to be the matrix product state tensors in right-canonical form up to a local unitary acting individually on the “physical” qudit of the cluster and each “virtual” qudit of the cluster.


    
  III. Theorem (Requirements on Measurements) The measurement basis used for preparation are guaranteed to be maximally entangled.


The above are all formally stated in Sec. <ref>. In addition, we note that we identify necessary and sufficient conditions on the local matrix product state tensor to guarantee that a given quantum state is gluable with our ingredients (Eq. (<ref>)). Having provided an informal prelude of our results, we now introduce the formalism from which we can prove these and other results. 




§ GENERAL SETUP AND FORMALISM 


In this section, we begin our more formal treatment of determining which quantum states are preparable using the ingredients present in the introduction.

To do so, we start by stating the assumed ingredients in the introduction more formally, defining the notion of gluable quantum states.

We subsequently show that such states are necessarily matrix product states and then state a theorem that the clusters used to prepare them are necessarily the tensors of the matrix product state in canonical form (up to local unitary actions on the qudits making up the cluster).

These tensors will be shown to satisfy a strict set of criteria, that will pave the way to a general mathematical formalism that enables proving the remaining results of this work.



 §.§ Formalizing Setup and Reduction to Matrix Product States 




Let us start by defining the notion of a `right-gluable' many-body quantum state (with a corresponding notion of `left-gluable' after making the appropriate changes):


    Definition (Right-Gluable Quantum States) We say that a many-body quantum state is right-gluable if it can be prepared deterministically with:
    
        
  (1) an initial product state of clusters of qudits arranged in a one-dimensional geometry;

        
  (2) a single round of finite-range, complete basis measurements with non-overlapping qudit support;
        

        
  (3) left-conditioned tensor product unitary feedback on unmeasured qubits.
        
        Here,  the tensor product structure is defined relative to the clusters, i.e. unitaries can act arbitrarily within clusters but not between them.
        
        Moreover, left-conditioning is a technical restriction we impose, requiring the correction unitary at a given unmeasured qubit only depends on measurements between clusters to the left of it. We thus only need to propagate classical information from left to right.
    

    We will also assume a minimality condition, which physically means that we do not use more measurements than necessary.
    
    Mathematically, this means that for any bipartition between the clusters, the Schmidt rank of the target state equals the Schmidt rank of the measurement projectors.
    
    See the discussion below Eq. (<ref>) for a simpler rephrasing.
    



The above ingredients appear rather general and could enable measurement patterns of the form shown in Fig. <ref> (a, top row), which look rather different than the measurements in the examples in Sec. <ref> that were nearest-neighbor and had non-overlapping geometric support.

Nevertheless, we show in Appendix <ref> that more elaborate measurement schemes such as the one shown in the figure are, in fact, equivalent to the restrictive scheme used in the examples and shown in Fig. <ref>(b).

The technique for demonstrating equivalence is depicted for the readers benefit in Fig. <ref>(a).

We will henceforth, without loss of generality, work with a nearest-neighbor protocol.

Moreover, since we only consider right-gluable quantum states in this work, we will sometimes refer to them as gluable states for brevity.




A further convenient observation is that we can always presume that at least one of the measurement outcomes gives the desired state—without requiring correction. Indeed, consider any particular choice of measurement outcomes {α_i} where i labels the location and α_i the outcome: by virtue of the state being gluable, we know there exists a tensor product unitary U_{α_i} which corrects the post-measurement state and produces the desired state. This means if we had simply applied this (non-entangling) unitary U_{α_i} to the initial clusters, then this particular measurement outcome would immediately give the desired result.

While the above are conventions which do not restrict the generality of our results, we will introduce a physical restriction for convenience: we consider translation-invariant set-ups, although many of our results hold more generally. More concretely, the initial clusters will be taken to be identical, and the measurement bases will be invariant under translation by one cluster. Of course we will not presume the measurement outcomes to be translation-invariant, nor the feedback step.



  §.§.§ Entangled Clusters and Minimality Condition


We now relate the outcomes of such measurement protocols (shown in Fig. <ref>(b)) to tensor network states (shown in Fig. <ref>(c)).

Let us observe that each cluster can be re-expressed graphically in a manner that looks more like a matrix product state tensor: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightdodgerblue] (0*1.3,0) rectangle (0*1.3 + 1, 0.4) ;
             at (0.5 + 0 * 1.3, 0.2) ψ;
            [color = black] (0.1 + 1.3*0, 0) – (0.1 + 1.3*0, -0.4);
            [color = black] (0.5 + 1.3*0, 0) – (0.5 + 1.3*0, -0.4);
            [color = black] (0.9 + 1.3*0, 0) – (0.9 + 1.3*0, -0.4);
             at (0.14, -0.55) ℓ_x;
             at (0.54, -0.55) x;
             at (0.94, -0.55) r_x;
               ⟶  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (0,0) ψ;
             at (-1.1, 0) ℓ_x;
             at (0, -0.9) x;
             at (1.15, 0) r_x;

where the `virtual' legs labeled ℓ_x and r_x are assumed to have local Hilbert space dimension χ and the `physical' leg labeled x has dimension d.

The aforementioned “minimality” condition is then equivalent to requiring that χ =rank(Λ), where Λ is the bipartite entanglement spectrum of the state. I.e., the resulting matrix product state has no zeros in the entanglement spectrum.





  §.§.§ Measurements and Error Bases


Similar to the clusters, it will also be useful to adopt a graphical notation for the different measurement outcomes.

In particular, let us suppose that we are measuring in a basis 𝒱 of states {|V_α⟩} with α = 1, ⋯, χ^2.

The projection operator onto each state can be graphically depicted as:

    [scale = 1.5, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightishgray] (0,-0.25) rectangle (0.7, -0.55) ;
            [color = black] (0.1, -0.25) – (0.1, 0);
            [color = black] (0.6, -0.25) – (0.6, 0);
             at (0.35, -0.4) ⟨V_α|;
          ⟶  1/√(χ)[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            
            [fill = lightishgray] (0,0) circle (0.3);
             at (0,0) V_α;

where the factor of χ^-1/2 is chosen for later convenience.


In this language, the states in the measurement outcome are re-interpreted as operators V_α, which means that the usual orthonormality of the measurement basis (i.e., ⟨ V_α|V_β⟩ = δ_ab) is equivalent to the following trace-orthonormality condition: 

    tr(V_α^† V_β) = χ δ_αβ.

I.e., the basis 𝒱 can be re-interpreted as an orthonormal basis for the space of χ×χ matrices.

In the error correction literature, such operators have been called an error basis <cit.>.

In fact, such literature tends to study the more restrictive notion of a unitary error basis, where each V_α is a unitary operator.

This is equivalent to the measurement basis being maximally entangled.

We emphasize that we do not impose this condition (since it is a priori not essential for preparing states); however, we will soon prove that unitarity is a consequence of our protocol.

As an example, in Sec. <ref> we considered the case χ=2, where the Pauli matrices defined an error basis {1, X, Z, ZX}; since these operators are all unitary (equivalently, the basis of Bell states (<ref>) is maximally entangled), it is indeed a unitary error basis.

Finally, as a technical remark, it will often be useful in proofs to use the following graphical notation for the full error basis:

    V_α = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightishgray] (0,0) circle (0.3);
             at (-0.0,0) 𝒱;
             at (-0.9, 0) χ;
             at (0.9, 0) χ;
             at (0.25, -0.6) χ^2;

where the leg labels indicate dimensionality of the leg and the downwards facing leg is the “α” leg.

Note that the trace orthonormality of the basis is equivalent to:

    tr(V_α^† V_β) =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (0, 0) – (0, 0.5); 
         at (0.25, 0.5) α;
         at (0.25, -1.5) β;
        [fill = lightishgray] (0,0) circle (0.3); 
        
        
         at (0.0,0) 𝒱̅;
        
        
        
        [color = black] (-0.8, 0) – (-0.8, -1);
        [color = black] (0.8, 0) – (0.8, -1);
        [color = black] (-0.8, -1) – (0.8, -1); 
        [color = black] (0, -1) – (0, -0.5-1); 
        [fill = lightishgray] (0,-1) circle (0.3); 
        
        
        
         at (0.,-1) 𝒱;
        
         = χ [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (0,0) – (0, -1); 
         = χ δ_αβ .

Moreover, we remark that the graphical notation here reveals an intriguing fact: 𝒱^†, when viewed as a χ^2 ×χ^2 matrix in the vertical direction of the above diagram, is the inverse of 𝒱 and is hence unitary. Therefore, we also obtain the following relation:

    1/χ [scale = 0.9, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightishgray] (0,0) circle (0.3); 
        [fill = lightishgray] (0,-1.2) circle (0.3); 
        [color = black] (-0.8, 0) – (-0.8, 0.2);
        [color = black] (0.8, 0) – (0.8, 0.2);
        [color = black] (-0.8, -1.2) – (-0.8, -1.4);
        [color = black] (0.8, -1.2) – (0.8, -1.4);
        
         at (-0.0,0) 𝒱;
         at (-0.0,-1.2) 𝒱̅;
        
            =    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0.4) – (-0.8, -1.6);
            [color = black] (0.8, 0.4) – (0.8, -1.6);

which will be invaluable in several proofs.



  §.§.§ Connection to Matrix Product States


The result of using this graphical notation is summarized in Fig. <ref>(c), which manifestly reveals the connection to matrix product states.

We make this connection stronger by showing that the resulting state actually has a very particular and useful form:

    Theorem 1 (Resources for Gluable Quantum States) Suppose that |Ψ⟩ is a translation-invariant right-gluable quantum state.
    
    Then the following are true: 
    
        
  (1) |Ψ⟩ has an exact matrix product state description

        
  (2) the unentangled clusters in the state preparation protocol |ψ⟩ are its matrix product state tensors in canonical form (labeled A) up to a tensor product of unitaries acting on each qudit of the cluster.
        
        In other words, 
        
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
                [color = black] (-1, 0) – (1, 0);
                [color = black] (0, 0) – (0, -0.8);
                [fill = lightdodgerblue] (0,0) circle (0.3);
                 at (-0.0,0) ψ;
                
                
                 at (0, -1.0) ;
                
                
         
             = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
                [color = black] (-1, 0) – (1, 0);
                [color = black] (0, 0) – (0, -0.8);
                [fill = lightdodgerblue] (0,0) circle (0.3);
                 at (-0.03,0) A;
                 at (-1.3, 0) u_L;
                 at (1.5, 0) u_R;
                 at (0, -1.0) u_P;

    where A is the MPS in right-canonical form and u_L, u_R, and u_P are unitaries (which are determined by the feedback protocol and measurement basis).

    
  (3) The measurement basis 𝒱 used for the preparation is maximally entangled.
    
    Equivalently, viewed as operators, the measurement basis is a unitary error basis.
    



Let us first remark two technical points.

In the above theorem, by right-canonical form, we mean that the Kronecker delta is a dominant right-eigenvector of the transfer matrix<cit.>. In tensor network notation, this becomes:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [color = black] (0, 0) – (0, -1.2); 
         [color = black] (0.8, 0) – (0.8, -1.2);
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        
        
        
        
        
         =   [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (0, 0) – (0.6, 0);
            [color = black] (0, -1.2) – (0.6, -1.2);
            [color = black] (0.6, 0) – (0.6, -1.2);

Such a form is highly convenient, as it allows to reduce many physical quantities of the state to local expressions.

In addition, this form has the property that the remaining `gauge' degree of freedom A_i → W A_i W^† (where W is unitary) can be used to also make the dominant left eigenvector diagonal, which has the physical interpretation of the Schmidt spectrum Λ^2 of a bipartition of the state.

Next, we remark that the proof of the above theorem is provided in detail in Appendix <ref> and logically relies on first proving Theorem 2, which we will state momentarily.


Finally, at a physical level, we remark that the above is powerful in that it heavily constrains “where to look” if one wants to prepare a given quantum state with purely measurement.

Indeed, the target state essentially fully specifies the clusters that can be used for the preparation protocol, and the measurement basis required for preparation is constrained to be maximally entangled (these are also called fusion measurements <cit.>).

In other words, the ingredients we utilize tell us it can never help to attempt to create a state by gluing with, e.g., non-maximally-entangled measurement bases.

To highlight the non-triviality of this theorem, we point out that if we had dropped the left-conditioning requirement, there do exist non-maximally-entangled bases for gluing certain quantum states, as shown in Sec. <ref>.

We thus see that the deceptively simple ingredient of left-conditioning (i.e., classical information only travels to the right) helps to build a remarkably structured framework, which we will use to uncover the physical properties (not) preparable via measurement.

The above theorem leads to a very useful corollary:

    Corollary 1 If |Ψ⟩ is a right-gluable quantum state, then initial clusters of its preparation protocol can always be chosen to be the matrix product state tensors in canonical form and one of the measurement outcomes V_1 ∈𝒱 can be chosen to be the identity.

The last claim follows from Theorem 1 stating that V_α is unitary. That means we can always use Ṽ_α = V_α V_1^† as an alternative error basis, which will still be correctable and a unitary error basis, which now satisfies Ṽ_1 = 1.

Another corollary of Theorem 1 is that all measurement outcomes are equally likely (see Appendix <ref> for a proof). This is not important for chains with open boundary conditions (such as the examples in Sec. <ref>), since the state is deterministically preparable, i.e., we can correct any possible measurement outcome. However, it can be used to infer that the state is efficiently probabilistically prepaparable even with periodic boundary conditions. For instance, in Sec. <ref> we explore additional conditions on the V_α operators which ensure that classical post-processing is very simple, and in such cases we can infer that the probability of successfully preparing the state on periodic boundary conditions is lower bounded by 1/χ^2 (in particular, it is independent of system size).

With these results in mind, the remaining task is to find an appropriate condition on the MPS tensor and the measurement basis that enables correctability.




 §.§ Local Tensor Criteria for Gluable States


We now discuss the properties of both the matrix product state tensor and the measurement basis that are required for the state to be gluable.

To do so, we start by recognizing that the corollary above implies that measurement outcomes V_α≠ V_1 ∈𝒱 can be viewed as virtual errors in the target matrix product state.

Correctability then reduces to asking the question as to when such virtual errors “push through to unitaries”.

Recall that by definition of gluable states we know that each wrong measurement outcome can be corrected by some physical unitary operator to the right of the location of the error:

    [scale = 0.65, baseline = ([yshift=-.5ex]current bounding box.center)] 
         at (-1.25, 0) V_α;
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.6) ;
         = [scale = 0.65, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.3) U^[ı]_α;

This suggests that we should be able to push the error through each matrix product state tensor individually.

In order to make this notion precise, let us first introduce the general concept of pushable operators of a matrix product state:

 
    Definition (Pushable Operators) Let A be a translationally-invariant matrix product state tensor.
    
    We say that an operator V^[0] is right-pushable with respect to A if there exists a sequence of operators V^[n ∈ℕ], U^[n ∈ℕ] such that:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.3, 0) V^[n];
             at (0, -1.2) ;
     
         = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.5, 0) V^[n + 1]; 
     at (0.1, -1.0) U^[n];

    where U^[n] is unitary.
    
    A similar definition can be applied for left-pushable operators.


The notion of pushable operators provides the bedrock of a formalism for understanding which matrix product states can be created deterministically from measurements and provides a condition on the matrix product state tensor required for gluability. Indeed, by formalizing the above intuition, we prove in the Appendix <ref> that the errors in gluable states are pushable operators. More generally:

    Theorem 2 (Tensor Characterization for Gluable States) 
    A translation-invariant state |Ψ⟩ is right-gluable if and only if its matrix product state representation A admits an error basis of right-pushable operators.
    
    This condition is equivalent to the existence of χ^2 trace-orthonormal operators {V_α} such that

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        
         at (-1, 0) V_α^[n];
        
         at (-1, -1.2) V̅_α^[n];
           =    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (1.05, 0) V^[n+1]_α;
        
         at (1.05, -1.2) V̅^[n+1]_α;
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;

where χ is the bond dimension of the MPS tensor, n is any non-negative integer, and V_α^[0] = V_α.


This local condition on the MPS tensor is crucial to proving Theorem 1. To give a taste of this, let us note that Eq. (<ref>) gives us a local condition on the transfer matrix. This is rather powerful, since the transfer matrix contains physical properties of interest; in particular its spectrum encodes correlation lengths and its eigenvectors encode entanglement properties.
If we combine this local criterion with Eq. (<ref>) (trace-orthonormality of the basis), we obtain

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (-0.8, 0) – (-0.8, -1.2);
        [color = black] (-1, 0) – (-1, -1.2);
        [color = black] (-1, 0) – (-1.4, 0);
        [color = black] (-1, -1.2) – (-1.4, -1.2);
        
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        
        
        
        
        
         = χ∑_α [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.8, 0) – (1.4, 0); 
        [color = black] (-0.8, -1.2) – (1.4, -1.2); 
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        [fill = lightishgray] (0.9,0) circle (0.3);
         at (0.9, 0) V^[1]_α;
        [fill = lightishgray] (0.9,-1.2) circle (0.3);
         at (0.9, -1.2) V̅^[1]_α;
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;

Here we see the Kronecker delta appear. By further manipulating this local condition, one can in fact prove that the Kronecker delta is a dominant right eigenvector of the MPS transfer matrix, thereby proving we are in canonical form (property (2) in Theorem 1). While the details are in the Appendix, we refer the reader to Sec. <ref> where we use the same ingredients in a somewhat simpler setting.

Finally, we note that having proven that we are in canonical form also allows us to deduce the last property in Theorem 1, namely that the error basis is unitary. This is because an MPS in canonical form has a more natural relationship between `virtual' and `physical' legs, such that V_α pushing through to a physical unitary operator can be used to prove that, indeed, V_α itself must be unitary; we again refer to the Appendix for a proof.

The above push-through condition motivates us to characterize gluable quantum states by the manner by which measurement errors push through the matrix product state.

Indeed, inspired by the examples in Sec. <ref>, we distinguish two types of pushable operators.



    Definition (Topological and Local Errors) Let V be a right-pushable operator with respect to A associated with a sequence V^[n ∈ℕ] (where V = V^[0]).
    
    We can define two types of these operators: 
    
        
  * We say that V is a local error, and equivalently can be locally corrected, if the sequence of operators (V^[n], U^[n]) can be chosen to trivialize at some n (i.e. there exists m such that V^[n > m], U^[n > m] = 1).
    
        
  * Conversely, we say that V is a topological error if the sequence can be chosen to never trivialize.
        
        In such a case, V requires non-local correction, where one using string operators to pair up and annihilates topological errors (see below for examples).
    
    Let us remark that local errors and topological errors are not mutually distinct.
    
    In other words, some errors could be both topological or local.


[footnote]We already saw an example of this in Sec. <ref>: the GHZ state appeared as the β=0 limit in Sec. <ref>, where the Z error was topological, but it also appears as the β = ∞ limit in Sec. <ref>, where Z was a local error.

Given these two types of errors, the remainder of the manuscript will be devoted to deriving physical properties of gluable quantum states from the properties of their measurement errors.

However, before this, we show our results in action concretely via the motivating examples introduced in Sec. <ref>.



 §.§ Illustration of Results with Previous Examples 


Deformed GHZ. We start by illustrating our abstract results for the case of the deformed GHZ state which we encountered in Sec. <ref>.

Note that the deformed GHZ state Eq. (<ref>) is an exact bond dimension two tensor network, whose tensors in right canonical form are given by: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
            
     
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = white] (0, -0.45) circle (0.15); 
            
            
            
            
            
            
            
     
            [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [fill = white] (0, -0.45) circle (0.15);
         =  e^β X

where the T-junction tensor above is the three-leg Kronecker delta tensor δ_ijk.

Note that the tensor above, when viewed as a state via the reshaping of Eq. (<ref>), is precisely initial cluster in the preparation protocol for the deformed GHZ.

Explicitly: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.5, 0) – (0.5, 0);
            [color = black] (-0.5, 0) – (-0.5, -0.8);
            [color = black] (0.5, 0) – (0.5, -0.8);
            [color = black] (0, 0) – (0, -0.8);
            [fill = white] (0, -0.45) circle (0.15); 
            
            
            
            
            
            
            
     
          ∝  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [rounded corners, fill = lightdodgerblue] (0*1.3,0) rectangle (0*1.3 + 1, 0.4) ;
             at (0.5 + 0 * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*0, 0) – (0.1 + 1.3*0, -0.4);
            [color = black] (0.5 + 1.3*0, 0) – (0.5 + 1.3*0, -0.4);
            [color = black] (0.9 + 1.3*0, 0) – (0.9 + 1.3*0, -0.4);
            
            
            
            [fill = white] (0.5 + 1.3*0, -0.2) circle (0.1);


In other words, we have that Eq. (<ref>) holds with u_L = u_R = u_P = 1.

Moreover, the measurements that we performed were in a maximally entangled basis—consistent with Theorem 1—and, in the operator language, they correspond to the Pauli matrices, which are unitary as predicted.

In particular, the Bell state projector ⟨V| (with V ∈{1, X, Z, ZX}) is given by: 

    [scale = 1.5, baseline = ([yshift=-.5ex]current bounding box.center)]
            [rounded corners, fill = lightishgray] (0,-0.25) rectangle (0.7, -0.55) ;
            [color = black] (0.1, -0.25) – (0.1, 0);
            [color = black] (0.6, -0.25) – (0.6, 0);
             at (0.35, -0.4) ⟨V|;
          ⟶  1/√(2)[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            
            [fill = lightishgray] (0,0) circle (0.3);
             at (0,0) V_α;

where for the particular case of getting the identity, we have that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            
            [fill = lightishgray] (0,0) circle (0.3);
             at (0,0) 1;
            
            
     
         = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);

where the straight line is the two-leg Kronecker delta δ_ij.

Notice that then the perfect outcome of Fig. <ref> becomes: 

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (7.5 -2, 0);
        ı in 0, ..., 2[color = black] (2*ı,0) – (2*ı, -1);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) A;
        [color = black] (-1.5, 0) – (-1.5, -1);
        [color = black] (5.5, 0) – (5.5, -1);

which is precisely the matrix product state for the deformed GHZ.

Finally, we remark that the measurement errors are pushable and topological, which follows from the deformed GHZ tensors satisfying: 
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) X;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) X;
             at (0, -1.0) X;
        
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) Z;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) Z;
             at (0, -1.0) ;

which we interpret as an instantiation of Theorem 2.

Deformed Cluster State. The deformed cluster state (Sec. <ref>) is similarly a bond-dimension two matrix product state whose tensors in canonical form are given by: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
            
     
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = white] (0, -0.45) circle (0.15);
            [fill = lightorange(ryb)] (0.4, 0) circle (0.15);

where the orange circle is once again the Hadamard and the white circle e^β X.

Note that in this case, we have that:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [rounded corners, fill = lightdodgerblue] (0*1.3,0) rectangle (0*1.3 + 1, 0.4) ;
             at (0.5 + 0 * 1.3, 0.2) ψ;
            [color = black] (0.1 + 1.3*0, 0) – (0.1 + 1.3*0, -0.4);
            [color = black] (0.5 + 1.3*0, 0) – (0.5 + 1.3*0, -0.4);
            [color = black] (0.9 + 1.3*0, 0) – (0.9 + 1.3*0, -0.4);
            
            
            
            
           =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [rounded corners, fill = lightdodgerblue] (0*1.3,0) rectangle (0*1.3 + 1, 0.4) ;
             at (0.5 + 0 * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*0, 0) – (0.1 + 1.3*0, -0.4);
            [color = black] (0.5 + 1.3*0, 0) – (0.5 + 1.3*0, -0.4);
            [color = black] (0.9 + 1.3*0, 0) – (0.9 + 1.3*0, -0.4);
            
            
            
            [fill = white] (0.5 + 1.3*0, -0.2) circle (0.1);
          ∝  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [rounded corners, fill = lightdodgerblue] (0*1.3,0) rectangle (0*1.3 + 1, 0.4) ;
             at (0.5 + 0 * 1.3, 0.2) A;
            [color = black] (0.1 + 1.3*0, 0) – (0.1 + 1.3*0, -0.4);
            [color = black] (0.5 + 1.3*0, 0) – (0.5 + 1.3*0, -0.4);
            [color = black] (0.9 + 1.3*0, 0) – (0.9 + 1.3*0, -0.4);
            
            
            
            [fill = lightorange(ryb)] (0.9 + 1.3*0, -0.2) circle (0.1);

which means that u_R = H in Eq. (<ref>), with u_L, u_P = 1.

Similarly, here the measurement basis is given by 𝒱 = {H, HX, HZ, HZX}, which is maximally entangled when viewed as quantum states and unitary when viewed as operators, thereby again providing an example of Theorem 1.

Consequently, one can check that the resulting tensor network will precisely be the deformed cluster state when all measurement outcomes yield H.

Finally, note that, once again, all measurement errors are pushable and topological, satisfying: 
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) X;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) Z;
             at (0, -1.0) X;
        
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) Z;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) X;
             at (0, -1.0) ;

In this example we glued using an error basis which did not contain the identity operator; relatedly, the initial |ψ⟩ state is not simply the MPS tensor of the target state (see Eq. (<ref>)). However, a crucial observation is that we can prepare the same state by using the MPS tensor as a starting ingredient and measuring in the Bell basis (by simply moving the Hadamard matrix from the error basis into |ψ⟩). This illustrates our general result stated in Corollary 1. The fact that we can always restrict to such a simpler scenario without loss of generality is a consequence of Theorem 1 ensuring that the error basis of a right-gluable state is always unitary. This additional structure is key to proving the general results in the next sections.

Deformed Trivial. Finally, the deformed trivial state we considered (Sec. <ref>) also has an exact tensor network description, with tensors in right-canonical form given by: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
            
     
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            
            [fill = white] (0.4, 0) circle (0.15);

where the white circle is e^α X with tanhα = e^-2β.

In this case, the clusters used for preparation: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.5, 0) – (0.5, 0);
            [color = black] (-0.5, 0) – (-0.5, -0.8);
            [color = black] (0.5, 0) – (0.5, -0.8);
            [color = black] (0, 0) – (0, -0.8);
            [fill = white] (0.5, -0.45) circle (0.15); 
            
            
            
            
            
            
            
     
          ∝  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [rounded corners, fill = lightdodgerblue] (0*1.3,0) rectangle (0*1.3 + 1, 0.4) ;
             at (0.5 + 0 * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*0, 0) – (0.1 + 1.3*0, -0.4);
            [color = black] (0.5 + 1.3*0, 0) – (0.5 + 1.3*0, -0.4);
            [color = black] (0.9 + 1.3*0, 0) – (0.9 + 1.3*0, -0.4);
            
            
            
            [fill = white] (0.9 + 1.3*0, -0.2) circle (0.1);

are precisely the matrix product state tensors with u_L, u_R, u_P = 1 in the parlance of Eq. (<ref>).

Similar to the GHZ example, the measurement basis is the Bell basis, which now makes manifest why a perfect measurement |1⟩ produces the target state with no need for correction.

Note that X errors and Z errors are both pushable, but now only X is topological, with Z being local.

In particular: 
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) X;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) X;
             at (0, -1.0) X;
        
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) Z;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) ;
             at (0, -1.0) Z;


Deformed Trivial as a Non-Example. Instead of Eq. (<ref>) we could consider the MPS tensor

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
            
     
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            
            [fill = white] (0.4, 0) circle (0.15);
            [fill = white] (-0.4, 0) circle (0.15);

where the white circle is now e^α X/2 with tanhα = e^-2β. This clearly generates the same deformed trivial state. However, this MPS is not in canonical form. Hence, according to our resource theorem (Theorem 1), we cannot use this as a wavefunction for our decoupled clusters. However, if we give up on our requirement that feedback is only left-conditioned, we can also glue these clusters. Remarkably, the error basis used for gluing will now be non-unitary: {1, X, Ze^α X, e^α X Y }. This basis is now no longer maximally entangled, but we can still correct the errors: e.g., while X pushes through to the right as in Eq. (<ref>), but Ze^α X can only be corrected by (locally) pushing to the left. This example highlights that a considerable amount of structure can be lost as soon as classical information needs to propagate both left and right. It remains to be seen whether a similarly complete framework can be worked out for such cases; however, it is equally unclear whether such bi-directional classical propagation provides a distinct advantage over simply using left-conditioning.





§ TOPOLOGICAL ERRORS: CONSTRAINTS ON ENTANGLEMENT AND ORDER
 

Having set up the basic formalism for understanding the structure of gluable quantum states in the previous section, here we consider constraints on the physical properties of such states when all measurement errors are topological or, equivalently, are non-locally corrected.

More precisely, we call a state topologically gluable if the unitary error basis 𝒱 = { V_α} used for gluing remains an error basis[We note that this condition is automatically implied if {V_α^[0]} are all topological errors and, e.g., the transfer matrix T has full rank (see Appendix <ref> for a proof) or the state is uniformly gluable (Sec. <ref>).] upon pushing through to 𝒱^[n] = { V^[n]_α} in Eq. (<ref>); this is in fact automatically a unitary error basis similar to the proof of Theorem 1. This is in contrast to states where we use local feedback, where necessarily V^[n]_α must trivialize for certain α.


The section is organized by first proving a basic but powerful constraint on the entanglement structure for gluable matrix product states of this form.

After this, we explore the connection between topologically gluable matrix product states and symmetry, enabling us to provide a complete classification of such states in a particular setting.

We conclude by discussing the relationship between short-range entangled topologically gluable quantum states and symmetry protected topological phases with both uniform and modulated symmetries.



 §.§ Generalities of Topologically Gluable States
 

Let us start by providing the most basic constraint on topologically gluable matrix product states.

This arises from the ability of pushing each error operator to a far-away region without losing its information (in particular, in finite chains this means the error gets pushed to the edge, as in the examples in Sec. <ref> and Sec. <ref>). This is reminiscent of measurement-based quantum computation <cit.>, where a flat (i.e., fully degenerate) entanglement spectrum is necessary to be able to `teleport' operators in this way. We show that this intuition indeed generalizes to our set-up:

    Theorem 3 (Exclusively Topological Errors Constrain Entanglement) Any topologically gluable matrix product state has a flat bipartite entanglement spectrum, i.e. the Schmidt spectrum Λ^2 is χ-fold degenerate where χ is the bond dimension, i.e., Λ^2 = ( 1/χ, 1/χ, ⋯ , 1/χ).


Proof. To prove the claim, we first recall that Theorem 1 guarantees we are in canonical form. More precisely, the Kronecker delta (i.e., the Choi state for the identity operator) is a dominant right eigenvector. Since its corresponding left eigenvector is the Schmidt spectrum Λ^2, it now suffices to prove that its left eigenvector is also the Kronecker delta.

To do so, let us denote the transfer matrix of the matrix product state as: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        
        
        
        
        
          =   [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.0, 0) – (1.0, 0);
            [color = black] (-1.0, -1.2) – (1.0, -1.2);
            [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
             at (0, -0.6) T;

and note that for topologically gluable states, we have that:

    [scale = 0.95, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.4, 0) – (1.0, 0);
            [color = black] (-1.4, -1.2) – (1.0, -1.2);
            [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
             at (0, -0.6) T^n;
            
            [fill = lightishgray] (-0.9,0) circle (0.3);
             at (-0.9, 0) V^[0]_α;
            [fill = lightishgray] (-0.9,-1.2) circle (0.3);
             at (-0.9, -1.2) V̅^[0]_α;
          = 
         [scale = 0.95, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.0, 0) – (1.4, 0);
            [color = black] (-1.0, -1.2) – (1.4, -1.2);
            [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
             at (0, -0.6) T^n;
           
            [fill = lightishgray] (0.9,0) circle (0.3);
             at (0.9, 0) V^[n]_α;
            [fill = lightishgray] (0.9,-1.2) circle (0.3);
             at (0.9, -1.2) V̅^[n]_α;

for all α, with 𝒱^[n] = {V^[n]_α} forming an error basis for all n.

At this point, we can sum over alpha and use the diagrammatic identity introduced in Eq. (<ref>) to show that, for all n: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.0, 0) – (1.0, 0);
        [color = black] (-1.0, 0) – (-1.0, -1.2);
        [color = black] (-1.2, 0) – (-1.2, -1.2);
        [color = black] (-1.2, 0) – (-1.6, 0);
        [color = black] (-1.2, -1.2) – (-1.6, -1.2);
        [color = black] (-1.0, -1.2) – (1.0, -1.2);
        [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
         at (0, -0.6) T^n;
      =       [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.0, 0) – (1.0, 0);
        [color = black] (1.0, 0) – (1.0, -1.2);
        [color = black] (1.2, 0) – (1.2, -1.2);
        [color = black] (1.2, 0) – (1.6, 0);
        [color = black] (1.2, -1.2) – (1.6, -1.2);
        [color = black] (-1.0, -1.2) – (1.0, -1.2);
        [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
         at (0, -0.6) T^n;

Now, we can formally take the limit as n →∞ and using the fact that we are in canonical form, we have that:

    ∑_β[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            
        [color = black] (-1.2, 0) – (-1.2, -1.2);
        [color = black] (-1.2, 0) – (-1.6, 0);
        [color = black] (-1.2, -1.2) – (-1.6, -1.2);
        
        [color = black] (-1.0, 0) – (-1.0, -1.2);
        [color = black] (0.0, 0) – (0.0, -1.2);
        [color = black] (-1.0, 0) – (0.0, 0.0);
        [color = black] (-1.0, -1.2) – (0.0, -1.2);
        
        [color = black] (0.6, 0) – (0.6, -1.2);
        [color = black] (0.6, 0) – (1.0, 0);
        [color = black] (0.6, -1.2) – (1.0, -1.2);
        [fill = white] (0.6, -0.6) circle (0.25);
         at (0.6, -0.6) L_β;
        [fill = white] (0.0, -0.6) circle (0.25);
         at (0.0, -0.6) R_β;
         = ∑_γ[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            
        [color = black] (-1.2 - 0.4, 0) – (-1.2 - 0.4, -1.2);
        [color = black] (-1.2 - 0.4, 0) – (-1.6 - 0.4, 0);
        [color = black] (-1.2 - 0.4, -1.2) – (-1.6 - 0.4, -1.2);
        [fill = white] (-1.6, -0.6) circle (0.25);
         at (-1.6, -0.6) R_γ;
        
        [color = black] (-1.0, 0) – (-1.0, -1.2);
        [color = black] (0.0, 0) – (0.0, -1.2);
        [color = black] (-1.0, 0) – (0.0, 0.0);
        [color = black] (-1.0, -1.2) – (0.0, -1.2);
        [fill = white] (-1.0, -0.6) circle (0.25);
         at (-1.0, -0.6) L_γ;
        
        [color = black] (0.4 -0.2, 0) – (0.4 -0.2, -1.2);
        [color = black] (0.4 -0.2, 0) – (0.8 -0.2, 0);
        [color = black] (0.4 -0.2, -1.2) – (0.8 -0.2, -1.2);

where the sums over β and γ are over the dominant eigenspace of the transfer matrix (that is 1-dimension for short-range entangled states) but higher dimensional for long-range entangled states.

Now, dotting on the left of both diagrams with the identity, yields: 

    ∑_βχ tr(R_β) [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (0.6, 0) – (0.6, -1.2);
            [color = black] (0.6, 0) – (1.0, 0);
            [color = black] (0.6, -1.2) – (1.0, -1.2);
            [fill = white] (0.6, -0.6) circle (0.25);
             at (0.6, -0.6) L_β;
         = (∑_γtr(R_γ) tr(L_γ) )
        [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (0.4 -0.2, 0) – (0.4 -0.2, -1.2);
        [color = black] (0.4 -0.2, 0) – (0.8 -0.2, 0);
        [color = black] (0.4 -0.2, -1.2) – (0.8 -0.2, -1.2);


Since the transfer matrix is gaurenteed to have at least one positive right eigenvector (since we are in right canonical form, that eigenvector is just the identity), the left hand side of the above equation is non-zero and hence the term in parenthesis on the right hand side is not zero.

As a direct consequence, the identity is in the span of the left eigenspace. 

Finally, since this has nonzero overlap with the Kronecker delta, it is the left eigenvector associated to the aforementioned dominant right eigenvector, proving that the entanglement spectrum of the transfer matrix is flat.

 ▪

As a remark, we use a similar style of reasoning to prove canonical form in the first place (claimed in Theorem 1) as shown in Appendix <ref>.


The flatness of the entanglement spectrum already suggests possible connections between topologically gluable quantum states and order.

Indeed, constraints on degeneracy of the entanglement spectrum regularly appear for non-trivial one-dimensional quantum states, ranging from long-range entangled states to symmetry-protected topological phases.

In what follows, we make this connection more precise by first formalizing the connection between topological errors and symmetry, which will then reveal how topological errors can constrain the order of gluable quantum states.

This reflects the two examples we saw in Sec. <ref> and <ref>, which consider deformed long-range entanglement and SPT order respectively.



 §.§ Topological Errors and Symmetry 


In discussing the relationship between topological errors and symmetry, it is convenient to distinguish between two types of topologically gluable matrix product states.

In particular, we will say that a matrix product state is uniform topologically gluable if the elements of its error basis 𝒱 satisfy a uniform push-through rule: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) V_α;
             at (0, -1.2) ;
     
         = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) V_α;
             at (0.05, -1.0) U_α;

for all V_α∈𝒱, i.e. V^[n ∈ℕ]_α = V_α in Eq. (<ref>) (in principle this only needs to hold up to a phase factor, which we omit for presentation purposes).

An example of such uniform states include our deformed GHZ state (Sec. <ref>), but also the deformed SPT example (Sec. <ref>) if we block into a unit cell of two sites.

Conversely, in the case where a topologically gluable matrix product state is not uniform, we will call it modulated, an example of which is the deformed SPT without blocking (Sec. <ref>). As we will discuss in Sec. <ref>, such cases are related to the notion of modulated symmetries, which are just starting to be explored in many-body quantum systems <cit.>.

Uniform topologically gluable states are associated with uniform symmetries, where the symmetry action does not vary from site to site of the chain. This is clear from rewriting Eq. (<ref>) as:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) V_α;
             at (1.2, 0) V^†_α;
             at (0, -1.2) ;
     
         = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
            
             at (0.05, -1.0) U_α;

This is the usual symmetry condition for a matrix product state <cit.>, indeed, it implies ∏_n (U_α)_n leaves the state invariant.
Hence, in the case where U_α is non-trivial operator, it gives a physical uniform symmetry of the matrix product state.

Conversely, when U_α = 1, we have that V_α forms a virtual symmetry of the matrix product state, whose presence indicates that the state is long-range entangled[This follows from the fact that for each eigenvector of the transfer matrix, V_α can be used to construct a second eigenvector with the same eigenvalue. We thus have a degenerate largest eigenvalue, which together with our minimality condition implies a physical diverging correlation length.].

This is exemplified by the Z errors in the deformed GHZ state. 



The relationship between pushable measurement errors and symmetry naturally inspires taking an algebraic lens on measurement errors.

In particular, one can consider the case where the measurement errors commute up to a phase, which we wil call abelian errors (indeed they give rise to abelian symmetries).

Cases with abelian errors have the useful property that correcting a measurement error does not affect other errors, since pushing one error along the matrix product will not transform the errors it passes along the way.

This property places rather strong constraints on the gluable quantum state and indeed, it is possible to fully classify matrix product states in these circumstances:


    Theorem 4 (Classification of Uniform Topologically Gluable Matrix Product States with Abelian Errors) Suppose that A is a uniform topologically gluable matrix product state tensor with an error basis 𝒱 = {V_α}, whose elements all commute up to a phase. Without loss of generality, we can choose one of them to contain the identity.
    
    Then, up to an isometry acting at the physical level, A is a is a matrix product state tensor with a physical dimension of χ^2 and virtual dimension of χ given by:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
             at (0.2, -0.75) α;
             = t_α   [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
                [color = black] (-0.8, 0) – (0.8, 0);
                [fill = white] (0,0) circle (0.3);
                 at (0,0) V_α;
                 at (0.0, -0.79) ;

where t_α=1,2,⋯,χ^2 are arbitrary complex numbers such that ∑_α |t_α|^2 = 1 to ensure normalization.


[footnote]One can always update the error basis as Ṽ_α = V_α V_1^†, which has the property Ṽ_1 = 1.

Proof (abridged). Since {V_α}_α is a unitary error basis, we know {V_α⊗V̅_β}_α,β is a basis for χ^2 ×χ^2-dimensional matrices. Hence, we can write the transfer matrix as:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         = ∑_α,β=1^χλ_α,β [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_α;
         at (0,-1.2) V̅_β;

for certain coefficients λ_α,β∈ℂ. The local characterization of gluability (Eq. (<ref>)) in the case of uniform symmetries tells us that for any γ =1,2,⋯,χ we have

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-1,0) V_γ;
         at (1,0) V^†_γ;
         at (-1,-1.2) V̅_γ;
         at (1,-1.2) V^𝖳_γ;
         at (-0.03,-1.2) A̅;

So far, these equations hold for any right-gluable MPS. However, we will now argue that for the case of abelian errors, only diagonal terms (i.e., where α = β) can survive in Eq. (<ref>). Since the errors are abelian, we can write V_γ V_δ = χ_γ,δ V_δ V_γ for χ_γ,δ∈ U(1). Then Eq. (<ref>) tells us

    λ_α,β = χ_γ,α/χ_γ,βλ_α,β.

Hence, λ_α,β≠ 0 implies that χ_γ,α = χ_γ,β for all γ. One can argue from the completeness of the unitary error basis that this implies α=β. From this one can deduce Eq. (<ref>); we refer to Appendix <ref> for details.

 ▪

It turns out that uniform topologically gluable states with abelian errors have additional properties which can be very convenient. In particular, in Appendix <ref> we show that abelian errors automatically have a group-like stucture. For instance, V_α V_β and V_α^† are automatically part of the unitary error basis. Such structure can help with the classical post-processing step. For instance, it means that instead of correcting for a single V_α error with a semi-infinite string, one can pair up V_α with other nearby elements (such as V_α^†) with finite string operators. Algebraically, this structure is known as a nice error basis, and these have been classified for small degrees <cit.>. It is thus promising that such mathematical physics results can be applied to the many-body physics problem of deterministically preparing quantum states with measurement.

We can give an even stronger classification result for the case of bond dimension χ=2. This is because the Pauli matrices are essentially the only unitary error basis for 2× 2 matrices <cit.>. We thus have:

    Corollary 2 Suppose that A is a uniform topologically gluable matrix product state tensor with bond dimension χ=2.
    
    Then, up to an isometry acting at the physical level, A is a is a matrix product state tensor with a physical dimension of 4 and is given by:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
             at (0.2, -0.75) α;
             = t_α   [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
                [color = black] (-0.8, 0) – (0.8, 0);
                [fill = white] (0,0) circle (0.3);
                 at (0,0) σ^α;
                 at (0.0, -0.79) ;

where σ^α are the Pauli matrices {1,X,Y,Z}. Here t_α=1,2,3,4 are arbitrary complex numbers such that ∑_α |t_α|^2 = 1.




As a particular example, the deformed GHZ state (Sec. <ref>) corresponds to t_1 = e^β/√(e^2β + e^-2β), t_2=t_3=0, and t_4 = √(1-t_1^2), after a Hadamard transformation on the physical qubit. Similarly, the deformed cluster state (Sec. <ref>) corresponds to t_α∝ ( e^2β,1,i e^-2β,1) after blocking two physical qubits into one four-state qudit. Finally, let us remark that the spin-1 AKLT state <cit.> is also preparable with measurement <cit.> and in fact is uniform topologically gluable in our framework, corresponding to t_1=0 and t_2=t_3=t_4=1/√(3).

The above classifications reveal a rich landscape of matrix product states that are deterministically preparable using one round of measurements and given a specific measurement basis.

Indeed, in a companion paper <cit.>, we explore some of the phenomenological landscape that arises as a consequence of the above classification (including how t_α relates to entanglement and correlation properties).

Below, we now formally present the “go” theorems mentioned in Sec. <ref>, making physical comments on the types of order present in the short-range entangled case of the above.





 §.§ Uniform, Short-Range Entangled Case
 

In the case of short-range entangled states, there are no virtual symmetries of the matrix product state and consequently the correction unitaries in Eq. (<ref>) are now all non-trivial and generate a group G_U, which we term index group of the state[We borrow this terminology from the error correction literature <cit.>.].

From our example of the deformed cluster state (Sec. <ref>), we may naturally wonder if the gluable state is then required to be a non-trivial SPT. 

This is indeed the case! 

Specifically, we prove in Appendix <ref> that for the abelian case, the measurement errors V_α must generate a non-trivial faithful irreducible projective representation of the above symmetry group.

This naturally connects uniform topologically gluable quantum states to SPT phases and results in the following theorem:


    Theorem 5 Every short-range entangled, uniform topologically gluable matrix product state with abelian errors is a non-trivial SPT phase protected by the symmetry group G_U.


A natural question is then whether the converse also holds.

In particular, does there exists a class of representatives in any abelian SPT phase that are required to be gluable?

This, in fact, is also true and the representatives in question are so-called minimally entangled quantum states in the SPT phase.


Such quantum states are required to have a bipartite Schmidt rank that is the minimal rank permissible by the entanglement degeneracy of the SPT phase, but we remark this does not constrain the nature of the correlations of the state.

As an example, for all values of β, the deformed cluster states considered (Sec. <ref>) are all minimally entangled SPTs—there Schmidt rank is rank(Λ) = χ = 2 as minimally required by the two-fold entanglement degeneracy required by the ℤ_2 ×ℤ_2 SPT order—but their correlation lengths for different values are drastically different and can even diverge.

The equivalence between minimally entangled abelian SPTs and uniform topologically gluable quantum states is established via the following theorem:


    Theorem 6 Any minimally-entangled translation-invariant SPT phase protected by a uniform abelian internal symmetry is topologically gluable.


We remark that, at a high level, this theorem shows that measurement-based preparability can go hand-in-hand with certain exotic classes of 1D orders.

The starting point for proving the above theorem is rather natural: the state being in a non-trivial SPT phase for a symmetry group G naturally gives virtual operators V_α which define a non-trivial projective representation of G <cit.>. In the abelian case, there is a unique bond dimension associated to such a projective representation, and our above minimal-entanglement condition can then be used to prove that {V_α} indeed defines a unitary error basis. The full proof is provided in Appendix <ref>. Here we want to highlight an interesting subtlety.

In particular, one may wonder if the group G which defined the initial SPT phases necessarily coincides with the index group G_U of the resulting gluable state.

Surprisingly this is not the case! In fact, G_U need not even be a subgroup[However, it must be a quotient group. The simplest non-trivial example arises from the χ=2 SPT phase protected by G = ℤ_4 ×ℤ_4 symmetry; the resulting index group of this gluable state will be G_U = ℤ_2 ×ℤ_2 which turns out to be identified with a quotient group of G but not a subgroup.] of G.

Indeed, we share a corollary for the proof of the above theorem, which may be of independent interest:

    Corollary 3 Suppose |Ψ⟩ is a minimally entangled SPT state protected by a uniform abelian internal symmetry G and labeled by a factor set ω.
    
    If Z_ω = {g ∈ G | ω(g, h) = ω(h, g),  ∀ h ∈ G} is the projective center of the group associated with ω, then |ψ⟩ is also a non-trivial SPT pase protected by an abelian symmetry G' ≃ G/Z_ω, whose factor set ω' is maximally non-commuting, i.e., its projective center is trivial Z_ω' = {1}.

We refer to Refs. else_2012_maximallynon, else2012non2 for a discussion of the notion of maximally non-commuting SPT phases.



 §.§ Modulated Case: Dipole SPTs 


Having addressed the uniform case in detail, we now turn to the comparatively more exotic modulated case for the case of short-range entangled states.

In such a case, the modulation of the measurement errors as they are swept through virtual bonds of the tensors is accompanied by a modulated site-to-site action of the correction unitary at the physical level.

Moreover, if the measurement error operator is inserted at the boundary (with suitable boundary conditions), the resulting correction symmetry string will generate a modulated symmetry of the system.

For arbitrary modulated symmetries, the structure of the resulting symmetry could be system-size dependent.

This sort of “UV/IR mixing” is a regular feature of systems with modulated symmetries and makes a completely general analysis of the modulated case challenging.

Indeed, a full theory of short-range entangled states is still lacking, though there has been recent progress in understanding several examples for certain modulated symmetries <cit.> and a general classification in one-dimension for dipole modulated symmetries <cit.>.

As such, below we address a few examples of preparable modulated topologically gluable SPT states.

In all cases, it is in some sense the SPT properties of the state that enable the gluing of these states.

This suggests a more general connection between topologically gluable states to modulated SPTs that we leave for future work to address in generality.



  §.§.§ Review of Ref. han2024dipole: Deformed Cluster State as Dipole SPT


We start by recognizing that the deformed cluster state in our motivating examples (Sec. <ref>) can already be interpreted as the simplest (albeit contrived) example of a dipole SPT phase.

In particular, traditionally the cluster state, and its deformed analogs, are viewed as being protected by a ℤ_2^even×ℤ_2^odd symmetry (corresponding to spin flips on even and odd sites).

These can be viewed as two distinct uniform symmetries if one forgets the one-site translation invariance of the cluster state and blocks two adjacent sites on the cluster state together.

Alternatively, if one demands the single-site translation symmetry of the state, it can instead be viewed as a ℤ_2^Q ×ℤ_2^D dipole SPT, where the former ℤ_2^Q is the uniform “ℤ_2-charge” symmetry of the state generated by ∏_x X_x and the latter is a modulated “ℤ_2-dipole” symmetry generated by ∏_x  even X_x.

Phrased in a more tensor network-based language, the existence of a uniform symmetry of the matrix product state guarantees that:

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-1,0) – (-1.5 + 4, 0);
        ı in 0, ..., 1[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
         at (0,-1.2) X;
         =     [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-1,0) – (-1.5 + 4, 0);
        ı in 0, ..., 1[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
         at (0, -1.2) ;
         at (-1.2,0) X;
         at (2.7,0) X;

and similarly, 

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-1,0) – (-1.5 + 4, 0);
        ı in 0, ..., 1[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
         at (1.5,-1.2) X;
         =     [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-1,0) – (-1.5 + 4, 0);
        ı in 0, ..., 1[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
         at (0, -1.2) ;
         at (-1.2,0) Z;
         at (2.7,0) Z;

In contrast, the presence of the ℤ_2^Q ×ℤ_2^D symmetries guarantees that:

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (0, -1.1) X;
     
           = -[scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) Y;
             at (-1.2, 0) Y;
             at (0, -1.0) ;
        
    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) Y;
             at (0, -1.2) ;
     
           = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) X;
             at (-1.2, 0) X;
             at (0, -1.2) ;

which can be checked is equivalent to Eq. (<ref>).

Both schemes are sufficient for guaranteeing that the deformed cluster state is gluable.



  §.§.§ Gluing ℤ_N^Q ×ℤ_N^D Dipole SPTs


Following our discussion of the deformed cluster state, we now discuss the gluing of a deformed variant of the ℤ_N^Q ×ℤ_N^D dipole SPTs introduced in Ref. han2024dipole.

To do so, it will be convenient to define the ℤ_N Pauli matrices (or clock and shift matrices) 𝒳 and 𝒵.

These operators act on a local Hilbert space of dimension N, labeled |g ∈ℤ_N⟩, and they satisfy the following algebraic relations: 

    𝒵^N = 𝒳^N = 1      X𝒵 = ω𝒵𝒳   𝒳𝒵^† = ω̅𝒵^†𝒳

where ω = e^2π i/N.

In terms of these, the two internal symmetry groups of these SPTs are given by ∏_x𝒳_x and ∏_x𝒳^x_x, which generate the charge and dipole symmetry respectively.


There are N distinct variants of the dipole SPT labeled by η∈ℤ_N.

In all such cases, a deformed variant of the fixed point wavefunction can be labeled by: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.0,0) A;
            
            
            
            
            
     
          = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (0, 0) – (0, -1);
        [color = black] (1.2, 0) – (-0.8, 0);
        
        [fill = lightorange(ryb)] (0.6,0) circle (0.25);
         at (0.6, 0) H_η;
        [fill = white] (0, -0.5) circle (0.2);

where the white circle is e^β (𝒳 + 𝒳^†) and the orange circle denotes a dipolar “Hadamard”-esque matrix:

    H_η  = ∑_g, h = 1^Nω^η g( h - g)|g⟩⟨h|

These tensors are in right canonical form and satisfy the following dipolar SPT rules, which can be expressed as:

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (0, -1.0) 𝒳^†;
     
           = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
            
            
             at (-1.75, 0) (𝒵^†)^η𝒳;
             at (1.7, 0) 𝒳^†𝒵^η;
             at (0, -1.0) ;
        
    
        
        
        [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.8, 0) (𝒵^†)^η𝒳;
             at (0, -1.2) ;
     
           = ω^-η[scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) 𝒳^†;
             at (-1.2, 0) 𝒳;
             at (0, -1.2) ;

The rules above are rather generic and apply, in some form, to any minimally entangled representative of the ℤ_N ×ℤ_N^D dipole SPT phase.

Rules in hand, we now discuss how to prepare these states with measurement.


As always, we envision preparing the tensors above as quantum states.

Subsequently, we measure the virtual qudits in the maximally entangled unitary error basis defined by the ℤ_N Pauli matrices: 𝒱 = ⟨𝒳, 𝒵⟩.

Note that the dipole SPT rules of Eq. (<ref>), can be rearranged to provide push through rules for (𝒵^†)^η𝒳^† and (𝒵^†)^η.

To ensure correctability, we consider the the case where d_η = gcd(η, N) = 1 (i.e. η and N are co-prime).

In such a case, the aforementioned operators generate the ℤ_N Paulis and we are guarantees that we can correct any virtual insertions just using the SPT property.

This demonstrates the preparability of the deformed ℤ_N^Q ×ℤ_N^D dipole SPT.

The same argument applies to any minimally entangled representative of the ℤ_N^Q ×ℤ_N^D dipole SPT for d_η = 1.




§ LOCAL AND TOPOLOGICAL ERRORS: CORRELATION VERSUS ENTANGLEMENT


Having provided a detailed analysis of the constraints imposed on gluable quantum states with exclusively topological errors, in this section, we will now consider the case where there exist both topological and local errors in the system.

In particular, we first show that the presence of even one local error in the system forces there to exist zero correlation length operators in the state (a statement, which we will make more precise in the matrix product state language shortly).

Subsequently, we will provide some extended physical intuition on the above result before stating the main result of this section: a no-go theorem demonstrating that certain quantum many-body states are not gluable, or equivalently cannot be prepared using the ingredients informally laid out in the introduction.




 §.§ Local Errors Constrain Correlations


As stated above, here we will consider a scenario where a subset of the measurement errors are locally correctable.

In this case, we will prove a simple, but powerful constraint on the correlations of the state.

To do so, let us first recall that correlation functions in a matrix product state are controlled by the spectrum of the transfer matrix <cit.>.

Indeed, the correlation function of a generic operator 𝒪 (either point-like or string-like) is a sum of exponential decays given by: 

    ⟨𝒪(x) 𝒪(y)⟩ =  ∑_λ∈spec(T) c_𝒪^λ e^-|x - y|/ξ_λ

where ξ_λ = 1/log(1/λ) and c_𝒪^λ are coefficients that depend on the choice of operator.

As a consequence, we will refer to the spectrum of the transfer matrix more physically as the correlation spectrum.

Let us remark that, by the requirement of normalization of the state, the largest transfer matrix eigenvalue is required to be 1 and degeneracies in this eigenvalue always signify long-range entanglement[Indeed, degeneracies in the largest transfer matrix eigenvalue imply that there exists an operator that fails to satisfy cluster decomposition: ⟨𝒪(x) 𝒪(y) ⟩→⟨𝒪(x) ⟩⟨𝒪(y) ⟩ for large separations |x - y|. Consequently, the resulting state cannot even approximately be connected to a product state with a finite-depth local unitary and is hence long-range entangled.].

Zeros in the transfer matrix spectrum are associated with operators whose correlation length is exactly zero [For fixed point states, aside from degeneracies in the largest transfer matrix eigenvalue, the remaining eigenvalues are always zero.].

Consequently, seeing such zeros in the correlation spectrum indicates the presence of operators whose connected correlation functions, while not identically zero, are zero beyond a certain distance.


With an understanding of the correlations in the matrix product state, we are prepared to state and prove the following theorem:


    Theorem 7 (Local Errors Constrain Correlations) Suppose that A is a matrix product state tensor and V is a (non-identity) measurement error that can be corrected at the physical level using a unitary with finite local support.
    
    Then, the correlation spectrum of A has a zero.


Proof. Let us suppose that V is an operator that that can be locally corrected.

Then, this means that the measurement-error pushes through the matrix product state onto a unitary with a support on a bounded number of continguous sites n.

Consequently, we have that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.4, 0) – (1.0, 0);
            [color = black] (-1.4, -1.2) – (1.0, -1.2);
            [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
             at (0, -0.6) T^n;
            [fill = white] (-0.9,0) circle (0.3);
             at (-0.9, 0) V;
            [fill = white] (-0.9,-1.2) circle (0.3);
             at (-0.9, -1.2) V̅;
          = 
         [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.0, 0) – (1., 0);
            [color = black] (-1.0, -1.2) – (1., -1.2);
            [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
             at (0, -0.6) T^n;

The above naturally implies that (V ⊗V̅ - 1⊗1)T = 0.

Now, by assumption, V≠1 and hence the above operator is non-zero.

Thus, for any vector ⟨ϕ|∈ℂ^χ⊗ℂ^χ such that ⟨ϕ| (V ⊗V̅ - 1⊗1) = ⟨ψ|≠ 0, we have that ⟨ψ| T = 0 [Indeed, this same line of reasoning shows that if there is a subset ν⊂𝒱 that is locally correctable, then the number of zeros in the transfer matrix ζ is bounded from below by 

    ζ≥χ^2 - dim( ⋂_v ∈νker(v ⊗v̅ - 1))

].

This completes the proof.

 ▪

The above theorem shows that states with local errors are “closer to their fixed points”, at least at the level of their correlations.




 §.§ Local Errors and Their Correction from Local Unitaries


To provide some more intuition for the previous theorem, we show that in certain cases, matrix product states with local errors can be “partially glued” using a finite-depth local unitary circuit. 

Since such unitaries cannot increase the correlation length of a state (as they have finite light cones), this provides heuristic intuition for why the correlations of such states are more limited.


The aforementioned cases correspond to when each element of the error basis 𝒱 can be decomposed into a product of two sets of operators v_α V_β, with i = 1, ⋯, χ' and j = 1, ⋯χ^2/χ', where the v's are local errors and V's are topological errors.

In other words, they satisfy:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) V_α;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.3, 0) V^[1]_α;
             at (0, -1.0) U^[0]_α;
        
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.2, 0) v_α;
             at (0, -1.2) ;
     
           = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.2, 0) ;
             at (0, -1.0) u_α;

where V_α^[1] can be iteratively pushed off to infinity and U_α^[0] and u_α are unitary.

Such a structure arises, for example, in the deformed trivial state (Sec. <ref>) whose errors basis—the Pauli's—satisfy similar push-through conditions, with Z being a local error and X being topological.

We now demonstrate how this product structure of the errors allows to replace some of the measurements-and-feedback by conventional unitaries.

For maximal clarity we here demonstrate the key ideas using the example of the deformed trivial state, but the manipulations generalize to the more general product case structure.

The essential idea is to replace measurement and local classical post-processing with quantum processing.

To see this idea in action, let us recall that for the deformed trivial state, Bell measurement between two clusters (see Eq. (<ref>) for a tensor network depiction of the clusters) are used to glue the clusters together.

Operationally, one could perform this Bell measurement by first performing a control-NOT gate between the clusters visualized as: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.8) – (-0.7 + 2.3, -0.8);
            [fill = black] (1.6, -0.8) circle (0.07);
            [color = black] (0.7, -0.8) – (0.7, -1.2);
            [color = black] (1.6, -0.8) – (1.6, -1.2);
             at (0.7, -0.8) ⊕;

and subsequently, perform a Z-basis measurement on the target and a X-basis measurement on the control.

Note that if the outcome is |0⟩|+⟩, then the result will be to insert a projector onto the Bell state |1⟩.

This constitutes the ideal measurement outcome.

In the case, where we get either the |1⟩ or |0⟩ state, note that: 

    [scale = 0.7, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.8) – (-0.7 + 2.3, -0.8);
            [fill = black] (1.6, -0.8) circle (0.07);
            [color = black] (0.7, -0.8) – (0.7, -1.4);
            [color = black] (1.6, -0.8) – (1.6, -1.4);
             at (0.7, -0.8) ⊕;
            [fill = error-red, rounded corners] (0.3, -1.25) rectangle (1.1, -1.75);
             at (0.7, -1.5) ⟨1|;
            [fill = lightishgray, rounded corners] (0.3 + 0.9, -1.25) rectangle (1.1 + 0.9, -1.75);
             at (0.7 + 0.9, -1.5) ⟨+|;
     =     [scale = 0.7, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.8 - 0.4) – (-0.7 + 2.3, -0.8 - 0.4);
            [fill = black] (1.6, -0.8- 0.4) circle (0.07);
            [color = black] (0.7, -0.8) – (0.7, -1.8);
            [color = black] (1.6, -0.8) – (1.6, -1.8);
             at (0.7, -0.8 - 0.4) ⊕;
             at (0.7, -0.7) X;
            [fill = lightishgray, rounded corners] (0.3, -1.25 - 0.4) rectangle (1.1, -1.75 - 0.4);
             at (0.7, -1.5 - 0.4) ⟨0|;
            [fill = lightishgray, rounded corners] (0.3 + 0.9, -1.25 - 0.4) rectangle (1.1 + 0.9, -1.75 - 0.4);
             at (0.7 + 0.9, -1.5 - 0.4) ⟨+|;

and 

    [scale = 0.7, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.8) – (-0.7 + 2.3, -0.8);
            [fill = black] (1.6, -0.8) circle (0.07);
            [color = black] (0.7, -0.8) – (0.7, -1.4);
            [color = black] (1.6, -0.8) – (1.6, -1.4);
             at (0.7, -0.8) ⊕;
            [fill = lightishgray, rounded corners] (0.3, -1.25) rectangle (1.1, -1.75);
             at (0.7, -1.5) ⟨0|;
            [fill = error-red, rounded corners] (0.3 + 0.9, -1.25) rectangle (1.1 + 0.9, -1.75);
             at (0.7 + 0.9, -1.5) ⟨-|;
     =     [scale = 0.7, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.8 - 0.4) – (-0.7 + 2.3, -0.8 - 0.4);
            [fill = black] (1.6, -0.8- 0.4) circle (0.07);
            [color = black] (0.7, -0.8) – (0.7, -1.8);
            [color = black] (1.6, -0.8) – (1.6, -1.8);
             at (0.7, -0.8 - 0.4) ⊕;
             at (1.6, -0.7) Z;
            [fill = lightishgray, rounded corners] (0.3, -1.25 - 0.4) rectangle (1.1, -1.75 - 0.4);
             at (0.7, -1.5 - 0.4) ⟨0|;
            [fill = lightishgray, rounded corners] (0.3 + 0.9, -1.25 - 0.4) rectangle (1.1 + 0.9, -1.75 - 0.4);
             at (0.7 + 0.9, -1.5 - 0.4) ⟨+|;

The above means that, errors on the left measurement insert an X measurement error between the clusters and errors on the right measurement insert a Z measurement error.

While correcting the topological X error requires a non-local string as explored extensively in the previous sections, correcting the local Z error only requires a local action of Z^a on the physical qubit immediately to the right of the measurement, classically conditioned on the measurement outcome of the right qubit above (a = 0 for |+⟩ and a = 1 for |-⟩).

This local classical post-processing can be replaced with the following quantum processing: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.7) – (-0.7 + 2.3, -0.7);
            [fill = black] (1.6, -0.7) circle (0.07);
            [color = black] (0.7, -0.7) – (0.7, -1.8);
            [color = black] (1.6, -0.7) – (1.6, -1.8);
            [color = black] (2.3, -0.7) – (2.3, -1.8);
             at (0.7, -0.7) ⊕;
            [fill = lightorange(ryb)] (1.6, -1.1) circle (0.1);
            [fill = black] (1.6, -1.35) circle (0.07);
            [fill = black] (2.3, -1.35) circle (0.07);
            [color = black] (1.6, -1.35) – (2.3, -1.35);
            [fill = lightorange(ryb)] (1.6, -1.6) circle (0.1);
            [color = red] (1.4, -1.0) rectangle (2.5, -1.7);

where the orange circles are once again Hadamard gates, the conditional gate is a control-Z gate, and the purpose of the gate in the red box is effectively to check whether the left qubit is in the |+⟩ or |-⟩ state and use a quantum conditional gate to correct it on the right.

Note that the red box is simply just a control-NOT, but we have emphasized its internal structure for didactic reasons, since it can be interpreted as (quantum) feedback which checks the state of the to-be-measured ancilla.

Indeed, one can show that: 

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            ı in 0, ..., 1[color = black] (-0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, 0);
            [color = black] (-0.7 + 2.3*ı, 0) – (-0.7 + 2.3*ı, -0.8);
            [color = black] (0.7 + 2.3*ı, 0) – (0.7 + 2.3*ı, -0.8);
            [color = black] (0 + 2.3*ı, 0) – (0 + 2.3*ı, -0.8);
            [fill = white] (0.7 + 2.3*ı, -0.3) circle (0.15);
            [color = black] (0.7, -0.7) – (-0.7 + 2.3, -0.7);
            [fill = black] (1.6, -0.7) circle (0.07);
            [color = black] (0.7, -0.7) – (0.7, -1.8);
            [color = black] (1.6, -0.7) – (1.6, -1.8);
            [color = black] (2.3, -0.7) – (2.3, -1.8);
             at (0.7, -0.7) ⊕;
            [fill = lightorange(ryb)] (1.6, -1.1) circle (0.1);
            [fill = black] (1.6, -1.35) circle (0.07);
            [fill = black] (2.3, -1.35) circle (0.07);
            [color = black] (1.6, -1.35) – (2.3, -1.35);
            [fill = lightorange(ryb)] (1.6, -1.6) circle (0.1);
            [color = red] (1.4, -1.0) rectangle (2.5, -1.7);
            [fill = lightishgray, rounded corners] (0.3, -1.25 -0.1) rectangle (1.1, -1.75 - 0.1);
             at (0.7, -1.5 - 0.1) ⟨0|;
            
            
            
            
            
            
            
     
     = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.7 + 2.3*0, 0) – (0.7 + 2.3*1, 0);
            [color = black] (-0.7 + 2.3*0, 0) – (-0.7 + 2.3*0, -0.8);
            
            [color = black] (0 + 2.3*0, 0) – (0 + 2.3*0, -0.8);
            [fill = white] (1.15 + 2.3*0, 0) circle (0.15);
            
            
            [color = black] (0.7 + 2.3*1, 0) – (0.7 + 2.3*1, -0.8);
            [color = black] (0 + 2.3*1, 0) – (0 + 2.3*1, -0.8);
            [fill = white] (0.7 + 2.3*1, -0.3) circle (0.15);
            [color = black] (0.7 + 1, -1.05 +0.3) – (0.7 + 1, -1.05 - 0.2);
            [fill = lightishgray, rounded corners] (0.3 + 1., -0.8 +0.3) rectangle (1.1 + 1., -1.3 +0.3);
             at (0.7 + 1, -1.05 +0.3) ⟨+|;

What this means is that by turning our classically-conditioned on-site feedback into a quantum gate, the corresponding ancilla qubit is automatically disentangled and we thus do not need to measure it anymore. We have thus reduced the necessary measurements to a single qubit for “gluing” the two clusters together, with a topological error which can be corrected by a non-local string.

Since local unitary gates cannot change the correlation length of the state they are acting on, the above provides some intuition as to why local errors lead to zeros in the correlation spectrum.

Furthermore, we remark that, while unitary gates cannot change correlation lengths, they can affect the entanglement spectrum, further motivating why states with local errors can have non-flat entanglement spectrum.



 §.§ No-Go Theorem


Given the above theorem on local errors and zeros in the correlation spectrum and intuition for this result, we are now prepared to prove our final main result of this manuscript: a powerful no-go theorem on the preparability of quantum states with a single round of measurements and left-conditioned feedback.



    Theorem 8 (No-Go Theorem) Suppose |Ψ⟩ is a translation-invariant quantum state with a non-flat entanglement spectrum upon bipartitioning the infinite chain in two halves, and with no zeros in its correlation spectrum (i.e., its transfer matix has full rank).
    
    Then |Ψ⟩ is not right-gluable, i.e., it cannot be prepared with the ingredients listed in Sec. <ref>.


Proof. The proof follows by establishing a contradiction.

Let us suppose that |Ψ⟩ was gluable with an error basis 𝒱.

Further, suppose that the transfer matrix of the matrix product state representation of |Ψ⟩ had no zero eigenvalues in its spectrum and consequently was full rank.

Then, by Theorem 7, we know that |Ψ⟩ has no locally correctable errors and its errors are exclusively topological. 

Consequently, per Theorem 3 [We remark upon a subtlety that is glossed over in this proof. Namely, the errors all being topological was not strictly sufficient for showing a flat entanglement spectrum. It was also necessary to show that each 𝒱^[n] in Eq. (<ref>) was a unitary error basis. We show in Appendix <ref> that, when a quantum state has no zeros in its correlation spectrum, all errors being topological implies each 𝒱^[n] is a unitary error basis.], the entanglement spectrum is flat.

However, this is in contradiction with the assumption that |Ψ⟩ had a non-flat entanglement spectrum.

Hence, |Ψ⟩ is not gluable.

 ▪

As an example of a state with the aforementioned properties, we can consider a combination of the examples seen in Sec. <ref>. For instance, |Ψ⟩ = e^β∑_n X_n e^β' ∑_n Z_n Z_n+1|+⟩ is a translation-invariant state which admits an exact χ=2 MPS representation, and one can straightforwardly check that for β≠ 0 ≠β', its entanglement spectrum is not flat and its transfer matrix has full rank. Thus, this state cannot be prepared with the ingredients explored in the present work. This highlights it is in principle possible to highlight concrete boundaries between what is and what is not possible using measurement-based state preparation.









§ CONCLUSIONS AND OUTLOOK
 

In this work, we sought to isolate the power of measurement for creating one-dimensional quantum entanglement by characterizing states accessible with a single round of measurement and left-conditioned tensor product unitary feedback.

We showed that such states are required to have an exact matrix product state description and then uncovered local criteria on the matrix product state tensors that are necessary and sufficient conditions for preparability.

These local criteria not only directly informed the preparation procedure of such states but also placed strong constraints on their physical properties—dictating which states could or could not be prepared in different settings.

In the general case, we were able to uncover an intriguing trade-off in the power of measurement for creating interesting entanglement structure and correlations.

Namely, if the correlations of the state were rich (i.e., no zero-correlation length operators present in the state), the entanglement structure was heavily constrained (i.e., forced to be flat).

Conversely, in order to have a more expressive entanglement structure, the state was required to have zero correlation length operators.

This tradeoff then naturally led to the no-go theorem in the previous section.

Moreover, in more specialized settings (i.e. for uniform topologically gluable quantum states with abelian errors), we were even able to provide a full classification for the space of preparable states, whose phenomenology will be explored as part of a companion work <cit.>.

Finally, we revealed connections between preparable quantum states and order, finding that the manner in which a state was corrected, often directly informed its order.

This connection was made sharpest in the context of abelian symmetry protected topological phases where we found that all minimally entangled representatives of these phases were preparable, with the converse also holding under suitable conditions.

Our work also opens up many exciting opportunities for future research.

On the more practical side, our work opens the door to a large class of quantum many-body states that can be prepared with few quantum operations in contemporary quantum devices.

Such quantum states could be useful as initial states in quantum simulation experiments.

In such a case, they could be the starting point of some quench dynamics protocol or could be non-trivial inputs to more elaborate simulation schemes.

Moreover, they could also serve as inputs to benchmark contemporary quantum algorithms.

Such constant-depth preparation protocols are especially timely since a variety of platforms have recently demonstrated mid-circuit measurement capabilities in tuneable many-body quantum systems <cit.>.

On the more theoretical side, our work contributes to the recent push to develop a more refined organization and understanding of the complexity of quantum entanglement and correlations.

Indeed, the states we show are non-gluable in the main text are “more complex” in a precise sense than those that are gluable.

Along this direction, it would be interesting to study several immediate generalizations of this work.

Can our most complete classification results (Sec. <ref>) be extended to other scenarios, such as the case with local erorrs, modulated symmetries or non-abelian errors?

A more invasive change would be to incorporate feedback that is both left- and right-conditioned; we saw that in such cases, many basic properties (such as the measurement basis being maximally entangled) are no longer guaranteed, and it is unclear whether a rigid framework can exist.

More broadly, what states become accessible with multiple rounds of measurements[Studies of fixed point states in higher dimensions have revealed an interesting hierarchy in such scenarios <cit.>.]?

What if one gives up on the `measurement-only' condition and incorporates unitarily evolution as part of the ingredients (either Hamiltonian- or gate-based)?

Moreover, what can be said generally in higher dimensions?

Finally, if one relaxes the condition of deterministic preparation <cit.> or exact preparation <cit.>, what can be achieved?



A more complete understanding of any of these questions would help further foliate and organize the landscape of quantum states and provide deeper insights into the structure of accessible (i.e., physically occurring) quantum entanglement.






Note added: The posting of this preprint to the arXiv was coordinated with simultaneous postings by Smith et al. <cit.> and Stephen et al. <cit.>. Both discuss the measurement-based preparation of matrix product states, and were developed independently from this work.



§ ACKNOWLEDGEMENTS
 We would like to thank Richard Allen, Soonwon Choi, Jordan Cotler, Ana Lyons, Francisco Machado, Nandagopal Manoj, Neelam Prasad, Pablo Sala, Tomohiro Soejima, Ashvin Vishwanath, and Josephine Yu for input and feedback on parts of this manuscript.

We also thank user8675309 for related discussions on Mathematics Stack Exchange.

R.S. acknowledges support from the U.S. Department of Energy, Office of Science, Office of Advanced Scientific Computing Research, Department of Energy Computational Science Graduate Fellowship under Award Number
DESC0022158.

R.V. is supported by the
Simons Collaboration on Ultra-Quantum Matter, which
is a grant from the Simons Foundation (618615, Ashvin
Vishwanath).








§ ADDITIONAL DETAILS FOR MOTIVATING EXAMPLES 


In this appendix, we provide some additional details regarding the motivating examples provided in the main text.

Specifically, we provide derivations for the tensor networks of both the deformed cluster state and the deformed trivial state.

Furthemore, by computing the correlation spectrum of each state as a function of β, we justify claims made regarding their correlations in the main text.



 §.§ Additional Details for Deformed GHZ State

In the main text we mentioned that this state has a full correlation spectrum (for β≠ 0). To be more precise, we calculate its correlation spectrum (i.e., eigenvalues of the transfer matrix) to be:

    λ(T) = { 1 ,1 ,tanh(2β), tanh(2β)}.

The degeneracy highlights that the state is long-range entangled. The subleading values give rise to a correlation length ξ = 1/|lntanh(2β)|. This is picked up, e.g., by the string correlation function of the ∏_n X_n symmetry.



 §.§ Additional Details for Deformed SPT State

To see that the protocol in Sec. <ref> leads to e^β∑_n X_n|cluster⟩_N if all measurement outcomes are the ideal Bell state, let us first note that at β = 0, the state satisfies:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.8, -0.65) X;
             at (0.5, -0.65) Z;
             at (3.1, -0.65) Z;
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (2.2, -0.3) circle (0.1);
            
            
            
          =       [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            
            
            
            ;
            
            [rounded corners, fill = error-red] (0.8 + 1.3*0,-0.25 - 0.25) rectangle (1.5 + 1.3*0, -0.55 -0.25) ;
            [rounded corners, fill = error-red] (0.8 + 1.3*1,-0.25 - 0.25) rectangle (1.5 + 1.3*1, -0.55 -0.25) ;
            
            
             at (1.15, -0.65) ⟨X|;
             at (1.15 + 1.3, -0.65) ⟨Z|;
             at (1.8, -0.65) ;
             at (0.5, -0.65) Z;
             at (3.1, -0.65) Z;
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (2.2, -0.3) circle (0.1);

which followed from using the property of the GHZ that X_c_x|GHZ_3⟩ = X_l_x X_r_x|GHZ_3⟩ and the property of the Hadamard that XH = HZ.

By using the property of the GHZ that Z_c_x|GHZ_3⟩_x = Z_r_x/l_x|GHZ_3⟩_x, we can thus derive that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            
            
            
            ;
            
            
            
            [rounded corners, fill = error-red] (0.8 + 1.3*0,-0.25 - 0.25) rectangle (1.5 + 1.3*0, -0.55 -0.25) ;
            [rounded corners, fill = error-red] (0.8 + 1.3*1,-0.25 - 0.25) rectangle (1.5 + 1.3*1, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨X|;
             at (1.15 + 1.3, -0.65) ⟨Z|;
             at (1.8, -0.65) ;
             at (0.5, -0.65) Z;
             at (3.1, -0.65) Z;
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (2.2, -0.3) circle (0.1);
            
            
            
          =      [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) GHZ_3;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.5);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.65);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.5);
            
            
            
            
            
            
            ;
            ı in 0, ..., 1[rounded corners, fill = lightishgray] (0.8 + 1.3*ı,-0.25 - 0.25) rectangle (1.5 + 1.3*ı, -0.55 -0.25) ;
             at (1.15, -0.65) ⟨1|;
             at (1.15 + 1.3, -0.65) ⟨1|;
             at (1.8, -0.65) ;
            
            
            
            
            [fill = lightorange(ryb)] (0.9, -0.3) circle (0.1);
            [fill = lightorange(ryb)] (2.2, -0.3) circle (0.1);

Hence Eq. (<ref>) is the cluster state at β = 0,  and hence is the desired wavefunction for general β.

Moreover, we determine its correlation spectrum (i.e., eigenvalues of the transfer matrix) to be:

    λ(T) = { 1 , √(tanh(2β)), - √(tanh(2β)) , - tanh2β}.

This state hence has several non-trivial correlation lengths, the largest of which is ξ = 2/| lntanh(2 β)|.



 §.§ Additional Details for Deformed Trivial State


Now for a simple non-SPT example, we remark that we can prepare the state e^β ZZ|+⟩^⊗ N.

Such a state is strictly in the trivial phase for all values of β< ∞.

To see the tensor network representation of this state, we remark that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [fill = lightorange(ryb), rounded corners] (0, 0) rectangle (1, 0.5);
            [color = black] (0.1, 0) – (0.1, -0.3);
            [color = black] (0.9, 0) – (0.9, -0.3);
            [color = black] (0.1, 0.5) – (0.1, 0.8);
            [color = black] (0.9, 0.5) – (0.9, 0.8);
             at (0.5, 0.25) e^β ZZ;
           =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            
            [color = black] (0.1, 0.8) – (0.1, -0.3);
            [color = black] (0.9, 0.8) – (0.9, -0.3);
            [color = black] (0.1, 0.25) – (0.9, 0.25);
            [fill = white] (0.5, 0.25) circle (0.1);

where the red circle is the matrix:

    [  e^β e^-β; e^-β  e^β ] = e^β + e^-βX ∝ e^α X

where α = arctanh(e^-2β).

With this in mind, note that the full tensor network will look like:

    |Ψ⟩ = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-3.5, 0) – (3.5, 0);
        ı in -3,...,3[color = black] (ı, 0) – (ı, -0.7);
        ı in -3,...,3[fill = white] (ı + 0.3, 0) circle (0.1);


Moreover, we determine its correlation spectrum (i.e., eigenvalues of the transfer matrix) to be:

    λ(T) = { 1 , tanh(2β), 0, 0 }.

Unlike the other two examples, this state has non-trivial observables with zero correlation length. As discussed in the main text, this is intimately related to the fact that this state can be prepared where some errors are local rather than topological.



§ PROOF OF RESOURCE THEOREM AND LOCAL TENSOR CHARACTERIZATION 


This appendix is devoted to proving the resource and local tensor characterizations theorems of Sec. <ref> (Theorems 1 and 2).

Specifically, for the readers convenience, we restate the two theorems:





    Theorem 1 (Resources for Gluable Quantum States) Suppose that |Ψ⟩ is a translation-invariant right-gluable quantum state.
    
    Then the following are true: 
    
        
  (1) |Ψ⟩ has an exact matrix product state description

        
  (2) the unentangled clusters in the state preparation protocol |ψ⟩ are its matrix product state tensors in canonical form (labeled A) up to a tensor product of unitaries acting on each qudit of the cluster.
        
        In other words, 
        
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
                [color = black] (-1, 0) – (1, 0);
                [color = black] (0, 0) – (0, -0.8);
                [fill = lightdodgerblue] (0,0) circle (0.3);
                 at (-0.0,0) ψ;
                
                
                 at (0, -1.0) ;
                
                
         
             = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
                [color = black] (-1, 0) – (1, 0);
                [color = black] (0, 0) – (0, -0.8);
                [fill = lightdodgerblue] (0,0) circle (0.3);
                 at (-0.03,0) A;
                 at (-1.3, 0) u_L;
                 at (1.5, 0) u_R;
                 at (0, -1.0) u_P;

    where A is the MPS in right-canonical form and u_L, u_R, and u_P are unitaries (which are determined by the feedback protocol and measurement basis).

    
  (3) The measurement basis 𝒱 used for the preparation is maximally entangled.
    
    Equivalently, viewed as operators, the measurement basis is a unitary error basis.
    




    Theorem 2 (Tensor Characterization for Gluable States) 
    A translation-invariant state |Ψ⟩ is right-gluable if and only if its matrix product state representation A admits an error basis of right-pushable operators.
    
    This condition is equivalent to the existence of χ^2 trace-orthonormal operators {V_α} such that

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        
         at (-1, 0) V_α^[n];
        
         at (-1, -1.2) V̅_α^[n];
           =    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (1.05, 0) V^[n+1]_α;
        
         at (1.05, -1.2) V̅^[n+1]_α;
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;

where χ is the bond dimension of the MPS tensor, n is any non-negative integer, and V_α^[0] = V_α.


Since the proof is rather lengthy, we organize the following logical sections

    
  Subsection 1 We start by providing a proof of claim (1) of Theorem 1—every gluable quantum state is a matrix product state.

    
  Subsection 2 Subsequently, it will be necessary to prove Theorem 2, which shows that gluable is equivalent to a local criteria on the MPS tensors.

    
  Subsection 3 We conclude by claims (2) and then (3), given the ingredients in the previous subsections.





 §.§ Every Gluable Quantum State is a Matrix Product State 


The proof of claim (1) of Theorem 1 proceeds in two stages.

First, we prove that if a state is gluable, then its measurement preparation protocol can be viewed as performing nearest-neighbor measurements between disentangled clusters.

We subsequently show that this setting naturally produces matrix product states.




  §.§.§ Reduction to Nearest-Neighbor Measurements


To reduce a more general measurement scheme to a nearest-neighbor measurement scheme, let us recall that definition, measurements between clusters can only occur with some maximal range R, measured in units of the distance between clusters (e.g. in Fig. <ref> (a, top row), R = 2).

By then blocking R clusters together, we can convert this to a protocol with at most nearest-neighbor measurements [in units of the new clusters, cf. Fig. <ref>(a, second row)].

However, at this stage, recognize that there will be measurements that occur within clusters, unlike the setting considered in our examples.

To mitigate this, we can perform two tricks.


    
  (1) First, we re-order the measured qudits such that all inter-cluster and right-neighbor measured qudits are to the right of all the unmeasured qudits, which are to the right of all left-neighbor measured qudits [ as shown in  Fig. <ref>(a, third row)]. 
    
    Note that this inter-cluster re-ordering of the measured qudits has no physical effect on the resulting state as we discard the measured qudits in our measurement protocol.

    
  (2) Second, we can “group” measurements together to eliminate all inter-cluster measurements [shown in the last panel of Fig. <ref>(a)].

The result is a set of disentangled clusters with nearest-neighbor measurements with non-overlapping geometric support, identical to all the examples that we considered [shown in Fig. <ref>(b)].

With this simplification, left conditioning is equivalent to saying that the correction unitary for a given unmeasured qudit, depends on the measurement outcome for qudits states to the left of it.






  §.§.§ Gluable Quantum States are Matrix Product States


Given the reduction to nearest neighbor measurements, we are prepared to prove claim (1) of Theorem 1.


    Theorem B.1 [Claim (1) of Theorem 1] Any gluable quantum state |Ψ⟩ has an exact matrix product state description.


Proof. Suppose that a global state |Ψ⟩ is gluable.

Then this means that there exists a measurement basis |𝒱⟩ = {|V_α⟩} and an associated set of correction unitaries U^𝐦_x (with 𝐦 = {α_x = 1, ⋯χ^2} denoting the measurement record) that enable deterministically preparing |Ψ⟩.

As a remark, for notational convenience, we take x ∈ℤ, i.e. the chain is infinite, though the analysis below is identical for the open boundary condition case.

To set notation, let us denote the initial state as: 

    |Ψ_0⟩ = ⊗_x ∈ℤ|ψ⟩_(x_L) x (x_R) = ⋯[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            ı in 0, ..., 2[rounded corners, fill = lightdodgerblue] (ı*1.3,0) rectangle (ı*1.3 + 1, 0.4) ;
             at (0.5 + ı * 1.3, 0.2) ψ_ı;
            [color = black] (0.1 + 1.3*ı, 0) – (0.1 + 1.3*ı, -0.4);
            [color = black] (0.5 + 1.3*ı, 0) – (0.5 + 1.3*ı, -0.4);
            [color = black] (0.9 + 1.3*ı, 0) – (0.9 + 1.3*ı, -0.4);
            
            
            
            
            
            
            ;
            
            
         ⋯

Here, x_L and x_R label the qubits to be measured to the left and the right respectively.

Note that the clusters |ψ_x⟩ can in principle depend on position x.

Once again, for sake of notation we choose to drop this label but it can be restored easily.

With the above, we have that for every measurement outcome 𝐦, we have that:

    |Ψ⟩ = ⊗_x ∈ℤ (U^𝐦_x)^†⟨V^α_x|_(x-1)_R  x_L[⊗_x ∈ℤ|ψ⟩_(x_L)  x  (x_R)]    = ∑_𝐬∏_x ∈ℤ [(U^𝐦_x)^†]_s_x s'_xV_i_(x-1)_R i_x_L^α_xψ_i_x_L  i_x_R^s'_x|𝐬⟩
       = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (7.5 -1.7, 0);
        ı in 0, ..., 2[color = black] (2*ı,0) – (2*ı, -1.3);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) ψ;
            [fill = lightishgray] (2*ı+ 1,0) circle (0.3);
            [fill = lightorange(ryb)] (2*ı,-0.8) circle (0.25);
         at (2*0 + 1, 0) V^α;
         at (2*1 + 1, 0) V^β;
         at (2*2 + 1, 0) V^γ;
         at (-1.8, -0.02) ⋯;
         at (2*0, -0.8) U^𝐦_0;
         at (2*1, -0.8) U^𝐦_1;
         at (2*2, -0.8) U^𝐦_2;
         at (2*0 + 0.3, -0.65) †;
         at (2*1 + 0.3, -0.65) †;
         at (2*2 + 0.3, -0.65) †;    
         at (6.2, -0.02) ⋯;

where in the last line, we implicitly sum over repeated indices and 𝐬 = {s_x} labels the local Hilbert space dimension of the unmeasured qubits, with s_x = 0, ⋯ d-1 and the use of upper and lower indices having no meaning.

Note that the above automatically implies a matrix product state representation of the state.

In particular, let the tensor at location x be equal to 

    [A^𝐦_x]^s_x_i_x_L i_(x + 1)_L = [U^𝐦_x]^†_s_x s'_xV_i_(x-1)_R i_x_L^α_xψ_i_x_L  i_x_R^s'_x = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (1.0, 0);
        ı in 0, ..., 0[color = black] (2*ı,0) – (2*ı, -1.3);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) ψ;
            [fill = lightishgray] (2*ı- 1,0) circle (0.3);
            [fill = lightorange(ryb)] (2*ı,-0.8) circle (0.25);
         at (2*0 - 1, 0) V^α;
         at (2*0, -0.8) U^𝐦_x;
         at (2*0 + 0.3, -0.65) †;

Note that, in the above representation, the tensor may depend on 𝐦 but, by design, the global state is not.

 ▪ 




As explained in Sec. <ref> of the main text, we can always presume that there exists a measurement outcome 𝐦_0 such the post-measurement state is the desired state, i.e., there is no need for correction in that particular case. Indeed, Eq. (<ref>) confirms this point, since one can perform a basis transformation on our initial |ψ⟩ to absorb the correcting unitary for a given outcome. Without loss of generality, we can take this `ideal' measurement outcome to be 𝐦_0 = 1 = (⋯, 1, 1, 1, ⋯ ). The MPS tensor is thus equal to

    [A]^s_x_i_(x - 1)_R i_x_R =  V_i_(x-1)_R i_x_L^1 (ψ_x)_i_x_L  i_x_R^s_x'
    = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (0.7, 0);
        ı in 0, ..., 0[color = black] (2*ı,0) – (2*ı, -0.8);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) ψ;
            [fill = lightishgray] (2*ı- 1,0) circle (0.3);
        ;
         at (2*0 - 1, 0) V^1;


Let us further remark that V^1 must be invertible because if it were not, we could find smaller dimensional “virtual qudits”, with which to create our initial product state clusters, contradicting the minimality condition in Sec. <ref>.

Then, without loss of generality, we will write the measurement basis as 𝒱 = 𝒱B = {V_αB} with the property that V_1 = 1 (achieved by setting B = V_1). In summary, we have

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.7,0) – (0.7, 0);
        ı in 0, ..., 0[color = black] (2*ı,0) – (2*ı, -0.8);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) A;;
        ;
    
    =
     [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (0.7, 0);
        ı in 0, ..., 0[color = black] (2*ı,0) – (2*ı, -0.8);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) ψ;
            [fill = lightishgray] (2*ı- 0.9,0) circle (0.3);
        ;
         at (2*0 - 0.9, 0) B;

with measurement outcomes leading to random insertions of V_α on the bonds of the matrix product state.

Finally, we remind the reader that in Sec. <ref> we presume translation-invariance for convenience. More precisely, this means we will take A in Eq. (<ref>) to be site-independent. However, many of our proofs can be extended beyond this.



 §.§ Proof of Theorem 2: Local Criteria on Matrix Product State Tensors 


We now turn to proving our local criteria for matrix product states.

To do so, our strategy will be to first prove that:

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
         at (-1.25, 0) V_α;
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.6) ;
         = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.3) U^[ı]_α;

for a single V_α.

While the above might seem manifestly true given the assumption of left-conditioning, there is an important subtlety.

In particular, any measurement error with a zero probability, need not push through to a unitary (since we will never be required to correct such an error).

As such, we first prove that a single measurement error V_α has a non-zero probability (on an open chain geometry with generic boundary conditions) before proving the condition on the local tensor criteria.




    Lemma B.1. For any translationally invariant gluable wavefunction |Ψ⟩ defined on a finite system of length L (assumed to be much larger than the correlation length) with particular open boundary conditions, the probability of measuring a single virtual error is non-zero.

[footnote]To be precise, by correlation length here, ξ_λ = 1/log(1/λ) where λ is the largest non-identity eigenvalue of the transfer matrix.

Proof. Let us start by showing that, on a finite chain with open boundary conditions, the measurement outcome corresponding to a single virtual insertion V_αB in the center of the chain has a non-zero probability density of being measured.

Since we are predominantly interested in bulk properties, we let our target wavefunction have the following boundary conditions: 

    |Ψ⟩ = 1/𝒩[scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (7.5, 0);
        ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) A;
        
        
        
        [color = black] (-1.5, 0) – (-1.5, -1);
        [color = black] (7.5, 0) – (7.5, -1);
        [fill = white] (-1.5, -0.5) circle (0.35);
        [fill = white] (7.5, -0.5) circle (0.35);
         at (-1.5, -0.5) v_L^1/2;
         at (7.5, -0.5) v_R^1/2;

where v_L and v_R define vectors with non-zero overlap on the largest positive right and left eigenvectors of the transfer matrix, R and L and with no overlap on any other potential dominant eigenvectors. Note that this is generic in the case of short-range entangled phases, since they have a unique dominant eigenvector of the transfer matrix. There is thus only a non-trivial condition in the case of long-range entangled phases, in which case it exactly corresponds to the physical requirement that we obtain the appropriate bulk state in the thermodynamic limit.

For simplicity, we proceed by taking v_L = L and v_R = R, though the proof carries through more generally under these conditions.

With this target state in mind, the post-measurement state with a single bulk measurement error is:

    p_α = 1/χ^N𝒩[scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1,0) – (7, 0);
            [color = black] (-1,-1) – (7, -1);
            ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
                [fill = lightdodgerblue] (2*ı,0) circle (0.3);
                [fill = lightdodgerblue] (2*ı,-1) circle (0.3);
                 at (2*ı, 0) A;
                 at (2*ı, -1) A̅;
             at (7.5, 0) ⋯;
             at (-1.5, 0) ⋯;
             at (3, 0) V_α;
             at (7.5, -1) ⋯;
             at (-1.5, -1) ⋯;
             at (3, -1) V̅_α;

where 𝒩 is the normalization for the initial state of decoupled clusters and χ arose from the normalization in Eq. (<ref>).

Now, provided that system size N is sufficiently large, we have, by the power method:

    p_α = 1/χ^N𝒩 [scale = 0.75, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        
        
        [color = black] (-0.8, 0) – (-0.8, -1.2);
        [color = black] (0.8, 0) – (0.8, -1.2);
         at (-0.0,0) V_α;
         at (-0.0,-1.2) V̅_α;
        [fill = white] (-0.8,-0.6) circle (0.2); 
        [fill = white] (0.8,-0.6) circle (0.2);
         at (0.8, -0.6) R;
         at (-0.8, -0.6) L;
         = 1/(χ𝒩)^Ntr{[M^-1V_α M] [M^† V_α^† (M^-1)^†] Λ^2 } = 1/(χ𝒩)^Ntr(W^†_α W_αΛ^2) ≠ 0 .

Here, we used our assumption that rank(Λ) = χ and the subsequent existence of the canonical form to set  L = M^-1Λ^2 (M^-1)^† and R = M M^†, for some non-singular matrix M.

Note that in the last step, we used the fact that W_α^† W_αΛ^2 is positive semi-definite and non-zero.

Hence the probability density of the outcome above is non-zero.

 ▪

Given this proof on the probabilities, we now prove Theorem 2: our local tensor criteria for gluable quantum states.










    Theorem B.2 (First Part of Theorem 2  of Main Text) 
    A translationally invariant matrix product state is gluable if and only if there exists an error basis of pushable operators.


Proof. Let us remark that if there existed an error basis of pushable operators, then it is clear why the matrix product state is gluable.

As such, the only non-trivial direction is the “only if” direction.

If |Ψ⟩ is preparable with left conditioned feedback, then we know that the unitaries used for correction U_x^𝐦 = U_x^𝐦_<x, where 𝐦_<x = {α_y < x}.

Note that this naturally implies that U^1_<x = 1 (i.e. if there are only 1[Recall that “1” was the measurement outcome that we took, without loss of generality, to be the identity.] outcomes appearing to the left of x, then the correction unitary at x is the identity).

With this in mind, let us consider the measurement outcome 𝐦 = 1_< xα1_>x (that is we measured 1 everywhere except for at x where we measured α), which we know can happen according to the above lemma.

Then, we have that: 

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1,0) – (7, 0);
            ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
                [fill = lightdodgerblue] (2*ı,0) circle (0.3);
                 at (2*ı, 0) A;
             at (7.5, 0) ⋯;
             at (-1.5, 0) ⋯;
             at (3, 0) V_α;
        
        =     [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1,0) – (7, 0);
            ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
                [fill = lightdodgerblue] (2*ı,0) circle (0.3);
                 at (2*ı, 0) A;
             at (7.5, 0) ⋯;
             at (-1.5, 0) ⋯;
             at (4.1, -1.2) U_0(α);
             at (6.1, -1.2) U_1(α);

where we have emphasized that U_n(α) is a function of α and a function of n, the distance away from where the first virtual defect occurred.

Now, note that, by the minimality assumption of gluable quantum states, the bonds of the matrix product state are full-rank.

In other words, the following map (which takes into account the boundary):

    Γ_L^x: ℋ_phys^L→ℋ_virtual^L        Γ_L^x = [scale = 0.75, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.5,0) – (7, 0);
            ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
                [fill = lightdodgerblue] (2*ı,0) circle (0.3);
                 at (2*ı, 0) A;
                [color = red, -stealth, thick] (2*ı + 0.3, -1) – (2*ı + 0.3, -0.5);
            [color = red, -stealth, thick] (-1.3, -1) – (-1.3, -0.5);
            [color = orange, -stealth, thick] (6.8, -0.2) – (7.3, -0.2);
            
            [color = black] (-1.5, 0) – (-1.5, -1);

is surjective for all x. [Note that, if it was not, we could insert a projector into the virtual bond without affecting the state. Consequently, its bond dimension χ≥rank(Λ) violating the minimality assumption. Further note this is completely distinct from the concept of MPS injectivity, which we are not assuming.].

A similar condition holds for Γ_R.

Consequently, we have that:

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
         at (-1.25, 0) V_α;
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.6) ;
         = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.3) U^[ı]_α;

Now, note that because Γ_R (the right analog of Eq. (<ref>)) is surjective, there exists a map (Γ^x_R)^+ such that (Γ^x_R) (Γ^x_R)^+ = 1_ℋ_virtual^R (i.e. it is a right-inverse of Γ^x_R).

This map is the so-called Moore-Penrose pseudoinverse of Γ^x_R [In canonical form, the Moore-Penrose inverse of Γ_x^R is simply (Γ_x^R)^†.

Since we are not assuming canonical form (indeed, we later derive it), we work with the more general object.
].

Now, we apply (Γ_R^x+1)^+ to both sides of the above equation to get: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.3, 0) V_α;
             at (0, -1.2) ;
     
         = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
         at (-1.25, 0) V_α;
        [color = black] (-1.0,0) – (4, 0);
        [color = black] (0.5,-1.0) – (4, -1.0);
        
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.6) ;
        [color = black] (4, -1.0) – (4, 0);
        [fill = lightorange(ryb), rounded corners] (-0.5 + 1.5, -1.3) rectangle (4.2, -0.8);
         at  (2.7, -1) (Γ_R^x + 1)^+;
     = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
         at (-1.25, 0) ;
        [color = black] (-1.0,0) – (4, 0);
        [color = black] (0.5,-1.8) – (4, -1.8);
        
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -0.8);
            
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
            
             at (1.5*ı, -1.1) U^[ı]_α;
        [color = black] (1.5*1,-1.8) – (1.5*1, -1.4);
        [color = black] (1.5*2,-1.8) – (1.5*2, -1.4);
        [color = black] (4, -1.0 - 0.8) – (4, 0);
        [fill = lightorange(ryb), rounded corners] (-0.5 + 1.5, -1.3 - 0.8) rectangle (4.2, -0.8 - 0.8);
         at  (2.7, -1 - 0.8) (Γ_R^x + 1)^+;
        [color = red, dashed] (0.4, -2.4) rectangle (4.3, 0.5);
        [red] at (5.2, 0) = V_α^[1];

Hence, we have that: 
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill =  lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.3, 0) V_α;
             at (0, -1.2) ;
     
         = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
            
             at (1.5, 0) V^[1]_α; 
     at (0.1, -1.0) U^[0]_α;

The above argument can be repeated arbitrarily and hence, we have shown that V_α is pushable for all α, proving the claim.

 ▪ 



    Corollary B.1 [Second Part of Theorem 2] A matrix product state having χ^2 trace-orthonormal pushable operators is equivalent to it having χ^2 such operators that satisfy:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        
         at (-1, 0) V_α^[n];
        
         at (-1, -1.2) V̅_α^[n];
           =    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (1.05, 0) V^[n+1]_α;
        
         at (1.05, -1.2) V̅^[n+1]_α;
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;



Proof. We remark that if a matrix product state has a pushable operator, then Eq. (<ref>) automatically holds.

It suffices to show therefore that the converse is true.

Note that the transfer matrix of a matrix product state uniquely determines its tensors up to isometries acting at the physical level[This follows from the fact that the transfer matrix defines a complete positive channel whose Kraus operators are the matrix product state tensors <cit.>.].

Since Eq. (<ref>) implies that (V^[n]_α⊗V̅^[n]_α)T(V^[n]_α⊗V̅^[n]_α)^-1 = T,
 we have that:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill =  lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
         at (-1.4, 0) V^[n]_α;
         at (1.8, 0) (V^[n + 1]_α)^-1;
         at (0, -1.2) ;
    
     = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
        
         at (1.5, 0) ; 
     at (0.1, -1.0) U^[n]_α;

where U_α^[n] is a square isometric matrix, which implies that it is unitary.

This completes the proof.

 ▪ 






Theorem 2 in hand, we can move onto proving the rest of Theorem 1.





 §.§ Proof of Claims (2) and (3) in Theorem 1


We now aim to prove claims (2) and (3).

We do so in parallel, first showing that A (as defined in Eq. (<ref>)) is in canonical form, then proving that V_α  (which appear in the error basis V_α B [See discussion above Eq. (<ref>)]) is unitary, and then finally proving that B is unitary.

These three facts together simultaneously prove the two claims.






    Theorem B.3 Suppose that |Ψ⟩ is a translation-invariant gluable quantum state.
    
    Then the matrix product state representation of |Ψ⟩, as given by the tensor in Eq. (<ref>), is in right canonical form up to a unitary gauge transformation.


Proof. To show that we are in right canonical form, it suffices to show that the identity is in the dominant right eigenspace of the transfer matrix.

To do so, recall that since  |Ψ⟩ is a gluable matrix product state, for all α in the error basis, we have from Theorem 2, that:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) ψ;
         at (-0.0,-1.2) ψ̅;
        
         at (-1.25, 0) V_αB;
        
         at (-1.25, -1.2) V̅_αB̅;
           =    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.6, 0) – (0.6, 0); 
        [color = black] (-0.6, -1.2) – (0.6, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (1.05, 0) V^[1]_α;
        
         at (1.05, -1.2) V̅^[1]_α;
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;

In other words, V_α pushes through A.

Now, since V_αB is an error basis, we can sum both sides of the equation by α yielding (using Eq. (<ref>)): 

    χ [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (-0.8, 0) – (-0.8, -1.2);
        [color = black] (-1, 0) – (-1, -1.2);
        [color = black] (-1, 0) – (-1.4, 0);
        [color = black] (-1, -1.2) – (-1.4, -1.2);
        
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) ψ;
         at (-0.0,-1.2) ψ̅;
        
        
        
        
        
         =       χ [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-1.0, 0) – (0.8, 0); 
        [color = black] (-1.0, -1.2) – (0.8, -1.2); 
        [color = black] (-1.0, 0) – (-1.0, -1.2);
        [color = black] (-1.2, 0) – (-1.2, -1.2);
        [color = black] (-1.2, 0) – (-1.6, 0);
        [color = black] (-1.2, -1.2) – (-1.6, -1.2);
        
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;
        [fill = white] (-0.7, 0) circle (0.25);
        [fill = white] (-0.7, -1.2) circle (0.25);
         at (-0.7, 0) B^-1;
         at (-0.7, -1.2) B̅^-1;
        
        
        
        
        
          = ∑_α [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-0.8, 0) – (1.4, 0); 
        [color = black] (-0.8, -1.2) – (1.4, -1.2); 
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        [fill = lightishgray] (0.9,0) circle (0.3);
         at (0.9, 0) V^[1]_α;
        [fill = lightishgray] (0.9,-1.2) circle (0.3);
         at (0.9, -1.2) V̅^[1]_α;
        
         at (-0.0,0) A;
         at (-0.0,-1.2) A̅;

Now, since V_α^[1] is pushable, we know that we can iterate the action of the transfer matrix above to get: 

    χ [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-1.0, 0) – (0.8, 0); 
        [color = black] (-1.0, -1.2) – (0.8, -1.2); 
        [color = black] (-1.0, 0) – (-1.0, -1.2);
        [color = black] (-1.2, 0) – (-1.2, -1.2);
        [color = black] (-1.2, 0) – (-1.6, 0);
        [color = black] (-1.2, -1.2) – (-1.6, -1.2);
        
        
        [color = black] (0, 0) – (0, -1.2); 
         
        
        
        
        
        
        
        [fill = white] (-0.7, 0) circle (0.25);
        [fill = white] (-0.7, -1.2) circle (0.25);
         at (-0.7, 0) B^-1;
         at (-0.7, -1.2) B̅^-1;
        [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
         at (0, -0.6) T^n;
        
        
        
        
        
         = 
         
         
         [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1.0, 0) – (1.4, 0);
            [color = black] (-1.0, -1.2) – (1.4, -1.2);
            [rounded corners, fill = lightdodgerblue] (-0.4, -1.4) rectangle (0.4, 0.2) ;
             at (0, -0.6) T^n;
            [color = black] (0.9, 0) – (0.9, -1.2);
            [fill = lightishgray] (0.9,0) circle (0.3);
             at (0.9, 0) 𝒱^[n];
            [fill = lightishgray] (0.9,-1.2) circle (0.3);
             at (0.9, -1.2) 𝒱̅^[n];

Now, we take n to be arbitrarily large yielding:


    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-1.2, 0) – (-1.2, -1.2);
            [color = black] (-1.2, 0) – (-1.6, 0);
            [color = black] (-1.2, -1.2) – (-1.6, -1.2);
             {∑_βtr(B^-1R_β(B^-1)^†)  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-0.5, 0) – (0,0);
            [color = black] (-0.5, 0) – (-0.5,-1.2);
            [color = black] (-0.5, -1.2) – (0,-1.2);
            [fill = white] (-0.5, -0.6) circle (0.25);
             at (-0.5, -0.6) L_β;
           } =1/χ∑_γ[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-0.5, 0) – (0,0);
            [color = black] (0, 0) – (0,-1.2);
            [color = black] (-0.5, -1.2) – (0,-1.2);
            [fill = white] (0, -0.6) circle (0.25);
             at (0, -0.6) R_γ;
         [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-0.5, 0) – (0.9,0);
            [color = black] (-0.5, 0) – (-0.5,-1.2);
            [color = black] (-0.5, -1.2) – (0.9,-1.2);
            [fill = white] (-0.5, -0.6) circle (0.25);
             at (-0.5, -0.6) L_γ;
            [color = black] (0.4, 0) – (0.4, -1.2);
            [fill = lightishgray] (0.4,0) circle (0.3);
             at (0.4, 0) 𝒱^[n];
            [fill = lightishgray] (0.4,-1.2) circle (0.3);
             at (0.4, -1.2) 𝒱̅^[n];
        
       tr(B^-1R_β(B^-1)^†) [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-1.2, 0) – (-1.2, -1.2);
            [color = black] (-1.2, 0) – (-1.6, 0);
            [color = black] (-1.2, -1.2) – (-1.6, -1.2);
         = 1/χ∑_γ[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-0.5, 0) – (0,0);
            [color = black] (0, 0) – (0,-1.2);
            [color = black] (-0.5, -1.2) – (0,-1.2);
            [fill = white] (0, -0.6) circle (0.25);
             at (0, -0.6) R_γ;
         [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)]
            [color = black] (-0.5, 0) – (1.4,0);
            [color = black] (-0.5, 0) – (-0.5,-1.2);
            [color = black] (-0.5, -1.2) – (1.4,-1.2);
            [color = black] (1.4, 0) – (1.4, -1.2);
            [fill = white] (-0.5, -0.6) circle (0.25);
             at (-0.5, -0.6) L_γ;
            [color = black] (0.4, 0) – (0.4, -1.2);
            [fill = white] (0.4,0) circle (0.3);
            [fill = white] (1.4,-0.6) circle (0.25);
             at (1.4, -0.6) R_β;
             at (0.4, 0) 𝒱^[n];
            [fill = white] (0.4,-1.2) circle (0.3);
             at (0.4, -1.2) 𝒱̅^[n];

Note that there exists a β for which R_β is full rank and positive <cit.> and hence the left-hand side is non-zero.

Consequently, the above naturally implies that |1⟩ lives in the span of dominant right eigenvector |R_γ⟩.

As a consequence, the matrix product state is in canonical form up to a unitary gauge transformation (to make the corresponding left eigenvector diagonal).

 ▪

We now prove Claim (3).


    Theorem B.4 Let A be a translation-invariant gluable matrix product state. Then, the V_α operators that appear in the measurement basis 𝒱B are unitary.


Proof. To prove this, let us note that by Theorem B.2 and B.3, we have that A is in right canonical form.

As a consequence, the Moore-Penrose pseudoinverse of the map Γ^R_x defined near Eq. (<ref>), (Γ^R_x)^+ = (Γ^R_x)^†.

Consequently, using methods similar to Eq. (<ref>) we have that:

    V_α = Γ^R_x ∏_n U_α (Γ^R_x)^†

Now, because 

    [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
         at (-1.25, 0) V^-1_α;
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.6) ;
         = [scale = 0.8, baseline = ([yshift=-.5ex]current bounding box.center)] 
        
        [color = black] (-1.0,0) – (4, 0);
         at (4.4, 0) ⋯;
        ı in 0, ..., 2[color = black] (1.5*ı,0) – (1.5*ı, -1);
            [fill = lightdodgerblue] (1.5*ı,0) circle (0.3);
             at (1.5*ı, 0) A;
             at (1.5*ı, -1.3) (U^[ı]_α)^†;

Therefore, we also have that: V^-1_α = Γ^R_x ∏_n U_α^† (Γ^R_x)^†.

Finally, note that V_α^† = Γ^R_x ∏_n U^†_α (Γ^R_x)^†.

But then, this implies that V_α^† = V_α^-1.

This completes the proof.

 ▪ 

As an important remark, the same argument shows that any V_α^[n] that V_α pushes through to, is required to be unitary.

We now turn to proving the main theorem of this subsection.


    Theorem B.5 [Claims (1) and (2) of Theorem 1] Suppose that |Ψ⟩ is a translation-invariant gluable quantum state.
    
    Then, the unentangled clusters in the state preparation protocol |ψ⟩ are the matrix product state tensor in canonical form up to a tensor product of unitaries acting on each qudit of the cluster.
    
    In other words,    
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) ψ;
            
            
     
         = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1, 0) – (1, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightdodgerblue] (0,0) circle (0.3);
             at (-0.03,0) A;
             at (-1.3, 0) u_L;
             at (1.5, 0) u_R; 
     at (0, -1.0) u_P;

    where A is the MPS in right canonical form and u_L, u_R, and u_P are unitaries.
    
    Moreover, the measurement basis is maximally entangled or, when viewed as operators, form a unitary error basis.


Proof. If |Ψ⟩ is right gluable, then we know that |Ψ⟩ can be prepared from clusters |ψ⟩ along with entangling measurements in an error basis 𝒱B with 𝒱 unitary (Theorem B.4).

Furthermore, we know from Eq. (<ref>) that the matrix product state tensor associated with |Ψ⟩ is:

    [A]^s_x_i_(x - 1)_R i_x_R =  B_i_(x-1)_R i_x_Lψ_i_x_L  i_x_R^s_x' [u_P]_s_x' s_x

which is in right canonical form up to conjugating unitaries acting at the virtual level.

Therefore, it suffices to show that B is unitary.

To do so, let us start by noting that since 𝒱B is an error basis, a nice graphical notation for this error basis is:

    V_αB = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0) – (0.8, 0);
            [color = black] (0, 0) – (0, -0.8);
            [fill = lightishgray] (0,0) circle (0.3);
             at (-0.0,0) 𝒱B;
             at (-0.9, 0) χ;
             at (0.9, 0) χ;
             at (0, -0.9) χ^2;

where the leg labels indicate dimensionality of the leg and the downwards facing leg is the “α” leg.

Note that trace orthonormality implies that:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (0, 0) – (0, 0.5); 
        [fill = lightishgray] (0,0) circle (0.3); 
        
        
         at (0.0,0) 𝒱B;
        
        
        
        [color = black] (-0.8, 0) – (-0.8, -1);
        [color = black] (0.8, 0) – (0.8, -1);
        [color = black] (-0.8, -1) – (0.8, -1); 
        [color = black] (0, -1) – (0, -0.5-1); 
        [fill = lightishgray] (0,-1) circle (0.3); 
        
        
        
         at (0.,-1) 𝒱B;
        
        
        
        
        
          = χ  [scale = 1, baseline =  ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (0,0.4) – (0, -1.6);
                 [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightishgray] (0,0) circle (0.3); 
        [fill = lightishgray] (0,-1.2) circle (0.3); 
        [color = black] (-0.8, 0) – (-0.8, 0.2);
        [color = black] (0.8, 0) – (0.8, 0.2);
        [color = black] (-0.8, -1.2) – (-0.8, -1.4);
        [color = black] (0.8, -1.2) – (0.8, -1.4);
        
         at (-0.0,0) 𝒱B;
         at (-0.0,-1.2) 𝒱B;
        
        
        
        
        
            =  χ   [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-0.8, 0.4) – (-0.8, -1.6);
            [color = black] (0.8, 0.4) – (0.8, -1.6);





Now, note that the second equality automatically implies that: 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightishgray] (0,0) circle (0.3); 
        [fill = lightishgray] (0,-1.2) circle (0.3); 
        [color = black] (-0.8, 0) – (-0.8, -1.2);
        
        
        
        
         at (-0.0,0) 𝒱B;
         at (-0.0,-1.2) 𝒱B;
        
        
        
        
        
         = ∑_α BV_α V^†_αB^† = ∑_α B B^† =  χ^2  1,

where we used our earlier result that V_α is unitary.
Thus, we have that BB^† = 1, implying that B is unitary.

Consequently, ψ is related to the matrix product state tensor in canonical form up to a tensor product of unitaries acting on each qudit of the cluster.

Moreover, 𝒱B is a unitary error basis (or equivalently, the measurement basis is maximally entangled).

 ▪ 



 §.§ An Aside on Measurement Probabilities 






    Theorem B.6 For any gluable wavefunction |Ψ⟩ defined on a finite-size system with particular open boundary conditions, every measurement outcome is equally likely.



Proof. We do this by computing the probability explicitly.

Once again, we work with open boundary conditions and since we are predominantly interested in bulk properties, we let our target wavefunction have the following boundaries: 

    |Ψ⟩ = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1.5,0) – (7.5, 0);
        ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
            [fill = lightdodgerblue] (2*ı,0) circle (0.3);
             at (2*ı, 0) A;
        
        
        
        [color = black] (-1.5, 0) – (-1.5, -1);
        [color = black] (7.5, 0) – (7.5, -1);
        [fill = white] (-1.5, -0.5) circle (0.35);
        [fill = white] (7.5, -0.5) circle (0.35);
         at (-1.5, -0.5) v_L^1/2;
         at (7.5, -0.5) v_R^1/2;

where v_L and v_R define vectors with non-zero overlap on the largest positive right and left eigenvectors of the transfer matrix, R and L (with no overlap on any other potential dominant eigenvectors).

For convenience, we choose v_L = L and v_R = R.

We have that:

    p_𝐦 = 1/χ^N𝒩[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
            [color = black] (-1,0) – (7, 0);
            [color = black] (-1,-1) – (7, -1);
            ı in 0, ..., 3[color = black] (2*ı,0) – (2*ı, -1);
                [fill = lightdodgerblue] (2*ı,0) circle (0.3);
                [fill = lightdodgerblue] (2*ı,-1) circle (0.3);
                 at (2*ı, 0) A;
                 at (2*ı, -1) A̅;
             at (7.5, 0) ⋯;
             at (-1.5, 0) ⋯;
             at (3, 0) V_α_x;
             at (5, 0) V_α_x+1;
             at (1, 0) V_α_x-1;
             at (7.5, -1) ⋯;
             at (-1.5, -1) ⋯;
             at (3, -1) V̅_α_x;
             at (5, -1) V̅_α_x + 1;
             at (1, -1) V̅_α_x - 1;

Now, from the above theorem, each of these are pushable operators, indicating that the can be swept to the right to unitaries.

Consequently, we have that the overlap above is equal to 1.

Hence, 

    p_𝐦 = 1/χ^N 𝒩

for all measurement outcomes.

 ▪






§ PROOF OF CLASSIFICATION AND GO THEOREMS


This appendix is devoted to providing proofs for the classification and “go” theorems in the main text (Theorems 4 and 5, 6 respectively), which were proved in the context of uniform topological gluable quantum states.

To do so, we start by providing a more formal treatise on the relationship between uniform topological errors and symmetry.

This will rely heavily on the concept of an index group, introduced in Ref. knill1996group.

We will then show that the measurement errors form a faithful irreducible projective representation of this group and will rely heavily on the theory of abelian projective representations to prove our classification theorem.

Moreover, the connection with projective representations will make the connection with SPT phases rather natural.

This will enable proving our two go theorems.




 §.§ Uniform Topologically Gluable, Symmetry, and Classification 


Let us suppose that we have a uniform topologically gluable matrix product state A, with error basis 𝒱.

Then it is useful to have a name for the group generated by 𝒱⊗𝒱^*:


    Definition (Index Group) Suppose A is a uniform topologically gluable matrix product state tensor with an error basis 𝒱 = {V_α}.
    
    We call the group  G_U ≃⟨{V_α⊗V̅_α}⟩ the index group of the matrix product state.

Several useful lemmas immediately follow from this definition.

In particular:

    Lemma C.1 If A is a short-range entangled uniformly topologically gluable matrix product state tensor, then the index group is a symmetry group of the state.
 

Proof. To prove this, it suffices to show that the index group is a symmetry group of the matrix product state.

Suppose that A is uniform topologically gluable with error basis 𝒱 and index group G_U ≃⟨{V_α⊗V̅_α}⟩, then:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
         at (-1.3, 0) V_α;
         at (0, -1.2) ;
         at (1.3, 0) V^†_α;
     = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
        
       
         at (0, -1.0) U_α;

Hence, the global matrix product state is symmetric under U_α.

Let us further note that the matrix product state tensor A, viewed as a map from virtual degrees of freedom to physical degrees of freedom, defines a group homomorphism from ⟨{V_α⊗V̅_α}⟩ to ⟨{U_α}⟩.

Consequently, the U_α's define a linear representation of the index group G_U and the matrix product state is symmetric under ⟨{ U_α}⟩.

Finally, since A is injective after blocking <cit.>, this representation is faithful and hence ⟨{U_α}⟩≃ G_U.

Hence, the matrix product state is symmetric under G_U.

 ▪



    Lemma C.2. Suppose A is a topologically gluable matrix product state with an error basis 𝒱 = {V_α}.
    
    Then, the canonical isomorphism between G_U and ⟨{V_α⊗V̅_α}⟩ defines a faithful linear representation of G_U.
    
    Moreover, the canonical map between the generating set of G_U and {V_α} induces a faithful irreducible projective representation of G_U.


Proof. Let us note that, by definition, G_U ≃⟨{V_α⊗V̅_α}⟩ and denote the isomorphism by ρ: G →⟨{V_α⊗V̅_α}⟩⊆GL_ℂ(ℂ^χ⊗ℂ^χ).

It immediately follows that this defines a faithful linear representation of G_U because the map is injective, proving the first part of the theorem.


We now prove that there exists a map between G_U and ⟨{V_α}⟩ that defines a faithful and irreducible projective representation of G_U.

Note that for any element g ∈ G_U: 

    ρ(g) = ∏_α∈ S_g V_α⊗∏_α∈ S_gV̅_α = ν(g) ⊗ν̅(g)     where     ν(g) ≡∏_α∈ S_g V_α

for some list S_g of numbers between 1, ⋯, χ^2 where ν: G →⟨{V_α}⟩⊆GL_ℂ(ℂ^χ)

Note that since ρ(g) ρ(h) = ρ(gh), we have that ν(g) ν(h) = ω(g, h) ν(gh) where ω(g, h): G × G → U(1).

Thus, there exists a map between G_U and ⟨{V_α}⟩ that defines a projective representation of G_U.


We now show that this representation is faithful and irreducible.

To show that the representation is irreducible, let us remark that, by assumption that {V_α} are trace orthonormal and span the set of χ×χ matrices.

As a consequence, any subspace of ℂ^χ that is invariant under the action of all the V_α's must be invariant under any χ×χ matrix.

Hence, the only invariant subspaces for the ⟨{V_α}⟩ are {0} and ℂ^χ and hence the representation is irreducible.

We now show that the representation is faithful.

We do so by contradiction.

Suppose there existed a g ≠ 1 (the identity) such that ν(g) = e^i θ1.

Then, 

    ρ(g) = ν(g) ⊗ν̅(g) = 1⊗1

But since ρ(g) = ρ(1) and g ≠ 1 this contradicts the fact that ρ is a faithful representation.

Hence, if ν(g) = e^iθ1, g = 1 implying that it is faithful.

 ▪



  §.§.§ A Technical Foray Into Nice Error Bases



Having built up some of the technology for understanding the interplay between topological errors and symmetry, it will be helpful to introduce the concept of nice error basis and a convenient result on these error bases from literature.

This section can largely be skipped if one is only interested in proving the classification.

However, the results here are invaluable for demonstrating the connection with SPT.

In particular, we start by defining nice error basis as <cit.>: 



    Definition (Nice Error Basis) Let G be a group of order χ^2.
    
    A nice error basis in χ dimensions is given by a set {ρ(g) ∈𝒰(n) | g ∈ G } of unitary matrices that satisfy: 
    
        
  (i) ρ(1) = 1

        
  (ii) ρ(g) ρ(h) = ω(g, h) ρ(gh) for all g, h ∈ G, where ω: G × G → U(1)

        
  (iii) tr(ρ(g)) = 0 for all g ≠ 1.
    
    In the following Lemma, we will show that these are in fact unitary error bases with index groups given by G.


Conditions (i) and (ii) above gaurentee that nice error bases form some projective representation of a group.

We also quote a result by Knill <cit.> that shows that nice error bases are unitary error bases.


    Lemma C.3 Nice error bases are unitary error bases 


Finally, we remark upon one more useful lemma and then a theorem from literature (Theorem 1 of Ref. <cit.>):


    Lemma C.4 A nice error basis is necessarily a non-trivial projective representation of the group G.  


Proof. This proof follows from the theory of characters.

Suppose that one has a group of order |G| = χ^2 and ρ be a regular (i.e. trivial projective) representation of the group.

Then, χ(g) = Tr(ρ(g)) is traditionally called the character function of the group representation.

Now, note that if χ(g) = 0 for all g ≠ 1, then χ(1) must be an integer multiple of |G| <cit.>.

This immediately implies that nice error bases form a non-trivial projective representation.

In particular, note that, by property (i) of nice error basis, ρ(1) = 1 and hence χ(1) = χ.

But this is not an integer multiple of χ^2 for any χ > 1.

Therefore, ρ cannot be a linear representation of G.

 ▪




    Theorem C.1 Let {ρ(g)} be a set of unitary matrices parameterized by the elements of a finite group G. 
    
    The set is a nice error basis with index group G if and only if ρ is a unitary faithful irreducible projective representation of G of degree |G|^1/2.


With these results about nice error bases, we can prove a set of results that will naturally lead to our classification.

First,

    Theorem C.2 Let G_U be the index group associated to the unitary error basis 𝒱. If G_U is abelian, then the degree of the projective representation defined by {V_α} is √(|G_U|).
    
    Equivalently, any unitary error basis with abelian index group is equivalent to a nice error basis.


Proof.

From the corollary above, we know that the canonical map between the generating set of G_U and {V_α} defines a faithful and irreducible projective representation of G_U:

    ν(g) ≡∏_α∈ S_g V_α    such that    ν(g) ν(h) = ω(g, h) ν(gh)

for some list S_g of numbers between 1, ⋯, χ^2.

We start by proving that Z_ω = {g ∈ G_U | ω(g, h) = ω(h, g),  ∀ h ∈ G_U} = {1} (i.e. the projective center of the group is trivial).

To do so, suppose that g ∈ Z_ω.

Then, for all h ∈ G_U, particularly those h associated with ν(h) = V_α, we have that:

    ν(g) ν(h) = ω(g, h) ν(gh) = ω(h, g) ν(hg) = ν(h) ν(g)

But since the V_α's form a complete basis for the set of all χ×χ matrices by assumption, ν(g) commutes with all χ×χ matrices.

Hence, ν(g) = e^i θ1.

Since ν(g) is a faithful representation, g = 1.

Thus, Z_ω = {1}.

Now, by Ref. <cit.>, we have that: 

    deg(ν) = √(|G_U|/|Z_ω|) = √(|G_U|)

proving the first claim of the theorem.


Finally, since the projective representation defined by {V_α} is an irreducible and faithful projective representation of degree √(|G_U|), {V_α} is equivalent to a nice error basis by Theorem C.1.




 ▪



    Corollary C.1 The error basis 𝒱 of every topologically gluable matrix product state with an abelian index group is equivalent to a nice error basis.


Proof. The error basis 𝒱 of a topologically gluable matrix product state is a unitary error basis. Since by assumption, the index group is abelian, the error basis is then nice.

 ▪



  §.§.§ Proof of Classification Theorem


We are now prepared to prove our classification.



    Theorem C.3 (Theorem 4 of the Main Text) Suppose that A is a uniform topologically gluable matrix product state tensor with error basis 𝒱 = {V_g} and an abelian index group G_U.
    
    Then, the transfer matrix associated with matrix product state tensor can be written as:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         = ∑_g ∈ G_U |t_g|^2  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_g;

where t_g are arbitrary complex numbers such that ∑_g ∈ G_U |t_g|^2 = 1.

Since the transfer matrix uniquely determines the matrix product state tensors up to a local isometry, this classifies all topologically gluable matrix product state tensors with abelian index groups.


Proof. Since 𝒱 = {V_g} forms a complete basis of χ×χ matrices, {V_g⊗V̅_h} forms a complete basis for all χ^2 ×χ^2 matrices.

Hence, 

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         = ∑_g, h ∈ G_U t_g, h [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_h;

Now, since A is topologically gluable, for all a ∈ G_U

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-1,0) V_a;
         at (1,0) V^†_a;
         at (-1,-1.2) V̅_a;
         at (1,-1.2) V^𝖳_a;
         at (-0.03,-1.2) A̅;
         = ∑_g, h ∈ G_U t_g, h [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_h;
         at (-1,0) V_a;
         at (1,0) V^†_a;
         at (-1,-1.2) V̅_a;
         at (1,-1.2) V^𝖳_a;

Now, since {V_α} forms a projective representation of G_U (Lemma C.2): 

    V_a V_g V_a^† = ω(a, g) ω(ag, a^-1)/ω(a, a^-1) V_aga^-1≡χ_g, a V_aga^-1 = χ_g, a V_g

where in the last step we used that G_U was abelian.

Then: 

    ∑_g, h ∈ G_U t_g, h [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_h;
         at (-1,0) V_a;
         at (1,0) V^†_a;
         at (-1,-1.2) V̅_a;
         at (1,-1.2) V^𝖳_a;
         =  ∑_g, h ∈ G_Ut_g, hχ_g, a/χ_ h, a [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_h;
        t_g, hχ_g, a/χ_ h, a = t_g, h

Thus, for all non-zero t_g, h, χ_g, a/χ_h, a = 1.

As a consequence of this, note that, for all V_a ∈𝒱

    V_a V_h^† V_g V_a^† = χ_g, a/χ_h, a V_h^† V_g = V_h^† V_g [V_a, V_h^† V_g] = 0   ∀ V_a ∈𝒱

But because 𝒱 forms a complete basis of all χ×χ matrices, the above implies that V_h^† V_g = e^i θ1.

Hence, V_h = e^-i θV_g.

Since tr(V_g^†V_h) = χδ_g, h, we have that θ = 0 and g = h for non-zero t_g, h.

Hence:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         = ∑_g ∈ G_U t_g, g [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_g;

What is left is to show that t_g, g are real, positive, and sum to 1.

The fact that ∑_g ∈ G_U t_g, g = 1 follows from the fact that the identity is the dominant right (and left) eigenvector of the transfer matrix with eigenvalue 1.

The real and positive condition follows from the fact that the transfer matrix, when viewed in the vertical direction, is a density matrix.

In this language, t_g, g are the eigenvalues of the density matrix and thus must be real and positive.

As such:
    
    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         = ∑_g ∈ G_U |t_g|^2  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        
        [fill = white] (0,0) circle (0.25); 
        [fill = white] (0,-1.2) circle (0.25); 
        
         at (0,0) V_g;
         at (0,-1.2) V̅_g;

where |t_g|^2 = t_g, g are arbitrary numbers such that ∑_g ∈ G_U |t_g|^2 = 1.


 ▪


Note that in the main text, we phrase the statement in terms of the MPS tensor directly.

As stated in the theorem above, this is equivalent to the transfer matrix statement above because the transfer matrix uniquely determines the MPS tensor up to an isometry at the physical level <cit.>.




 §.§ Connection Between Uniform Topologically Gluable and SPT Phases 


Having provided a proof for the classification theorem, we now discuss the connection between such states and symmetry-protected topological phases.

In particular, we start with Theorem 5:

    Theorem C.4 (Theorem 5 of the Main Text)  Every short-range entangled, uniform topologically gluable matrix product state with abelian errors is a non-trivial SPT phase protected by the symmetry group G_U.


Proof. Recall that if the matrix product state is short-range entangled and has abelian errors, let us note a couple of facts.

First, its index group G_U is abelian and a symmetry of the state (Lemma C.1). 

Moreover, its errors 𝒱 = {V_g} form a nice error basis and necessarily form a non-trivial projective representation of the group  (Theorem C.2).

Consequently, we have from the uniform topologically gluable condition that:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
        
         at (0, -1.0) U_g;
     = [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
         at (-1.3, 0) V_g;
         at (1.35, 0) V_g^†;
         at (0, -1.2) ;

This implies that physical symmetries fractionalize into virtual operators that form a non-trivial projective representation of G_U labeled by some 2-cocyle ω.

Since this co-cycle defines a discrete invariant of the state, robust provided that the G-symmetry remains unbroken, the matrix product state is in a non-trivial SPT phase.

 ▪























Finally, we provide a proof for Theorem 6.


    Theorem C.5 Any minimally entangled, translation-invariant, SPT protected by an abelian internal symmetry is topologically gluable.


Proof. Suppose that |ψ⟩ is an infinite translationally-invariant SPT wavefunction protected by an abelian group G = {∏_x U_g, x}.

From Ref. <cit.>, it is known that semi-infinite string operators of the symmetry ∏_x < x_0 U_g, x act on the Schmidt vectors to the left and right of their endpoints as a projective representation of the group G with factor set ω∈ H^2(G, U(1)), which uniquely characterizes the SPT phase.

Consequently, the Schmidt spectrum Λ across any cut of the state can be organized into degenerate blocks, each labeled by an irreducible projective representation of the group G with factor set ω.




Since G is abelian, it follows that the degree of these irreducible projective representations are all the same and are given by deg(ν) = √(|G|/|Z_ω|), where Z_ω is the projective center of the factor set (see Theorem 2.21 of Ref. <cit.>).

Thus, an SPT has minimal entanglement if its Schmidt spectrum is only non-zero for a single block with the entanglement across a cut being: S = log(√(|G|/|Z_ω|)).

Consequently, translationally-invariant minimal entanglement SPT's are (1) captured by translationally-invariant matrix product states with bond dimension χ = √(|G|/|Z_ω|), (2) have flat entanglement spectrum, and (3) have virtual symmetry operators ν(g) satisfying:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
        
       
         at (0, -1.0) U_g;
     = e^i θ_g[scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-1, 0) – (1, 0);
        [color = black] (0, 0) – (0, -0.8);
        [fill = lightdodgerblue] (0,0) circle (0.3);
         at (-0.03,0) A;
         at (-1.3, 0) ν(g);
         at (0, -1.2) ;
         at (1.4, 0) ν^†(g);

and which form an irreducible projective representation of G with factor set ω.




We now wish to show that such states are topologically gluable by showing that some subset of the virtual symmetry operators form a nice error basis for this matrix product state.

To do so, let us note that, from the proof of Theorem 2.21 in Ref. <cit.>, if ν(g) ∈ Z_ω, then ν(g) = e^i _g1.

With this in mind, let us consider the map ρ: G →GL_ℂ(ℂ^χ) such that ρ(g) = ν(g) ⊗ν̅(g) with ker(ρ) = Z_ω.

Note that ρ forms a linear representation of G but is also a group homomorphism from G to G_U = ⟨{ν(g) ⊗ν̅(g) }⟩≃ G/Z_ω with size |G_U| = √(|G|/|Z_ω|).

By picking representatives g of the cosets [g] ∈ G/Z_ω, we can define a closely related map ρ': G_U →GL_ℂ(ℂ^χ) with ρ'([g]) = ν(g) ⊗ν̅(g), which defines a faithful linear representation of G_U.


The map ν'([g]) = ν(g) then defines a faithful projective representation of G_U with factor set ω': G_U × G_U → U(1) with ω([g], [h]) = ω(g, h).

The representation is further irreducible since the set of matrices {ν'([g])} consist of all elements of {ν(g) | g ∈ G} that are distinct up to phases.

Thus, since the former has no invariant subspaces, the latter also has no invariant subspaces.

Thus, ν([g]) is a faithful irreducible projective representation of degree √(|G_U|) = χ.

It follows from Theorem C.1 that it forms a nice error basis.

This, with the property in Eq. (<ref>), cements |ψ⟩ as topologically gluable.


 ▪


An independently interesting results follows from this.


    Corollary Suppose |Ψ⟩ is a minimally entangled SPT state protected by an abelian internal symmetry G and labeled by a factor set ω.
    
    Then |ψ⟩ is also an SPT protected by abelian symmetry G' ≃ G/Z_ω labeled by a maximally non-commuting factor set ω'.


Proof. The proof of this immediately follows from the proof of the theorem above.




§ SOME ADDITIONAL DETAILS ON NO-GO THEOREM PROOF 


In the main text, we proved a no-go theorem demonstrating that a state with no zeros in its correlation spectrum and a non-flat entanglement spectrum cannot be right-gluable.

We proved this by contradiction: if the state was gluable and had no zeros in its correlation spectrum, it could not have any locally correctable errors.

Consequently, all of its errors were topological.

To show indeed that this implies that the entanglement spectrum is flat (hence, deriving the contradiction required), we need the following Lemma.

    Lemma D.1 Suppose that |Ψ⟩ is a gluable matrix product state with an error basis 𝒱 of (exclusively) topological errors that push through to 𝒱^[n].
    
    If |Ψ⟩ has a full correlation spectrum, then 𝒱^[n] is a unitary error basis for all n. 


Proof. We proceed inductively.

First, let us note that 𝒱^[0]≡𝒱 is a unitary error basis.

Now, assume that 𝒱^[n] is a unitary error basis.

Subsequently, if |Ψ⟩ is gluable, then the transfer matrix satisfies:

    [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-0.03,-1.2) A̅;
         =  [scale = 1, baseline = ([yshift=-.5ex]current bounding box.center)] 
        [color = black] (-0.8, 0) – (0.8, 0); 
        [color = black] (-0.8, -1.2) – (0.8, -1.2); 
        [color = black] (0, 0) – (0, -1.2); 
        [fill = lightdodgerblue] (0,0) circle (0.3); 
        [fill = lightdodgerblue] (0,-1.2) circle (0.3); 
        
         at (-0.03,0) A;
         at (-1.3,0) (V^[n]_α);
         at (1.4,0) (V^[n + 1]_α)^†;
         at (-1.3,-1.2) (V̅_α^[n]);
         at (1.4,-1.2) (V^[n + 1]_α)^𝖳;
         at (-0.03,-1.2) A̅;

where V_α^[n] is unitary (see remark below the Theorem B.4) for all n and α.

To show that V_α^[n] is in fact an error basis,  first write the above equation as T = 𝕍_α T 𝕎_α^† where  𝕍_α = V^[n]_α⊗V̅^[n]_α and 𝕎_α = V_α^[n + 1]⊗V̅^[n + 1]_α.

Now, if we perform a singular value decomposition on T, we have that:

    T = X S Y^† = 𝕍_α X S Y^†𝕎_α S = (X^†𝕍_α X) S(Y^†𝕎^†_α Y)

where X and Y are unitary.

But note that both the left and right hand side of the implied equation defines a valid singular value decompositon for S.

Since |Ψ⟩ has a full correlation spectrum, S is non-singular.

Hence, since the singular vectors are unique up to unitary transformations U in degenerate singular subspaces, we have that (X^†𝕍_α X) = U and (Y^†𝕎_α Y) = U.

Consequently, 

    (X^†𝕍_α X)  = (Y^†𝕎_α Y) 𝕎_α = YX^†𝕍_α (YX^†)^†

Thus, 𝕎_α is related to 𝕍_α by unitary conjugation.

Thus, we have that: 

    |tr[(V_α^[n + 1])^† V_β^[n + 1]] |^2 = tr(𝕎_α^†𝕎_β) = tr(𝕍_α^†𝕍_β) = |tr[(V_α^[n])^† V_β^[n]] |^2 = χ^2 δ_αβ

Thus, tr[(V_α^[n + 1])^† V_β^[n + 1]] = χδ_αβ (note that when α = β, the argument of the trace is positive semi-definite picking out the phase).

Hence, it is a unitary error basis.

This proves the above assertion.

 ▪







